Что такое переменная в java. Пример без инициализации

За оператором объявления примитивной переменной может следовать оператор инициализации " = ", с помощью которого созданной переменной присваи­вается начальное значение.

1. Целые типы переменных

Целые типы различаются по размеру отведенной для них памяти. Характеристики целочисленных типов приведены в табл. 1.1. Табл. 1.1. Характеристики целочисленных типов Java
Как видно из приведенной таблицы, целые переменные, за исключением типа char , считаются в языке Java переменными со знаком. Целочисленные константы могут задаваться в программе одним из трех способов: в виде десятичных, шестнадцатеричных и восьмеричных значений. По умолчанию все числа интерпретируются как десятичные и относятся к типу int . Явно указать принадлежность к типу long можно, добавив в конце числа букву "l" или букву "L" . Шестнадцатеричное значение задается с помощью символов "0x" или "0X" , за которым значение числа (цифры 0-9 и буквы A-F или a-f), например: 0x7FFF . Число в восьмеричной записи должно начинаться с нуля, за которым следует одна или несколько восьмеричных цифр, например 077777 . Восьмеричные и шестнадцатеричные числа могут быть как положительными, так и отрицательными и изменяются в тех же диапазонах, что и числа в десятичном представлении (например, шестнадцатеричные числа типа byte имеют максимальное значение 0x7F и минимальное значение – 0x80 , а восьмеричные – соответственно 177 и – 200) Примеры объявления целых переменных: int x = 0 ; long i, j, k; byte a1 = 0xF1 , a2 = 0x07 ; short r1 = 017 ; Символы в Java определяются с помощью ключевого слова char и реализованы с использованием стандарта Unicode. Можно задать константу-символ в про­грамме или как обычный символ. Символьное значение должны быть заключено в пару одиночных апострофов, например: char symbol= "f" ; Другой способ записи символов: пара символов "\u" , за которой следует четырехзначное шестнадцатеричное число (в диапазоне от 0000 до FFFF), представляющее собой код символа в Unicode, например: char symbol = "\u0042" ; Некоторые символы, отсутствующие на клавиатуре, можно задавать с помощью так называемых escape-последовательностей, содержащих символ " \ ", за которым следует буквенный символ, идентифицирующий escape-последовательность, как показано в табл. 1.2. Табл. 1.2. Escape-последовательности, используемые в языке Java

Что еще почитать:

2. Вещественные типы переменных

Язык Java поддерживает числа и переменные с плавающей точкой обычной и двойной разрядности – типы float и double . Для чисел с плавающей точкой нужно указывает целую и дробную часть, разделенные точкой, например 4.6 или 7.0 . Для больших чисел можно использовать экспоненциальную форму записи (для отделения мантиссы от порядка используется символ "e" или символ "E"), например, число -3,58×107 записывается как –3.58E7 , а число 73,675×10-15 – как 73.675e-15 . Характеристики вещественных типов Java представлены в табл. 2.1. Табл. 2.1. Характеристики вещественных типов Java
Переменные с плавающей точкой могут хранить не только численные значения, но и любой из особо определенных флагов (состоянии): отрицательная беско­нечность, отрицательный нуль, положительная бесконечность, положительный нуль и «отсутствие числа» (not-a-number, NaN). Все константы с плавающей точкой подразумеваются принадлежащими к типу double . Чтобы задать число типа float , необходимо добавить в его конец символ "f" или символ "F" . Примеры объявления переменных с плавающей точкой: float x1 = 3.5f , x2 = 3.7E6f , x3 = - 1.8E-7f ; double z = 1.0 ;

3. Булевский тип переменных

Переменные булевского типа (логические переменные) могут принимать одно из двух значений: «истина» или «ложь» и используются в языках программирования в операциях отношения (сравнения) и логических операциях. Так, результатом сравнения 5 > 3 будет «истина», а результатом сравнения 8 < 1 будет «ложь». В отличие от C, где результату «ложь» сопоставлено целое значение типа int , равное 0, а результату «истина» – ненулевое значение типа int , и, соответственно, результатам сравнения присваивается целое значение (обычно 0 или 1), в Java для булевских переменных введен свой, отдельный тип данных. Переменные булевского типа в Java задаются с помощью ключевого слова boolean и могут иметь лишь одно из двух значений: true или false , например boolean switch = true ; Ссылка на перво

Тип данных определяется тремя составляющими:

• набором значений или объектов;
• набором операций, которые могут быть применены ко всем значениям в наборе;
• представлением данных, определяющим их хранение.

Какие бывают типы данных в Java?

Язык программирования содержит некоторые заранее определенные встроенные типы и позволяет программистам определять свои собственные, пользовательские.

В Java типы данных делятся на примитивные и ссылочные.

«Примитивный» означает, что дальнейшее его деление невозможно. Расширять или изменять его язык программирования не позволяет. Такой тип данных описывается примитивными и другими пользовательскими типами.

Переменная примитивного типа содержит значение, а ссылочная - адрес объекта в памяти.

Язык Java. время и дата

Составные данные делятся на классы, интерфейсы и массивы. Членами интерфейсного типа являются абстрактные методы и константы. В языке Java типы данных дата и время задаются конструктором Date():

• d = new Date().

Язык Java. Типы данных: String

Строка представляет собой класс, определенный в и он может быть использован для работы с текстом (последовательностью символов).

Объявление ссылочной String-переменной следующее: String str.

• str = new String ("Привет").

Что происходит при выполнении этого кода? Во-первых, выделяется память, и имя str связывается с этой ячейкой памяти. Это не отличается от объявления примитивной переменной. Второй фрагмент кода создает в памяти объект String с текстом «Привет» и сохраняет ссылку на него (или адрес памяти) в str.

Ссылочные типы данных Java также позволяют присвоить ссылку на объект, хранящуюся в одной переменной, другой. Обе они ссылаются на один и тот же объект в памяти. Это может быть достигнуто следующим образом:

• String str1;
• String str2;
• str1 = new String ("Привет");
• str2 = str1;

Объект String создается с помощью оператора new. Но так как строки используются часто, есть более простой способ его создания. Все строковые литералы, т. е. последовательность символов, заключенная в двойные кавычки, рассматриваются как объекты String. Поэтому вместо оператора new можно использовать строковые литералы:

• String str1 = "Hello".

Примитивные типы данных Java - byte, short, int, long, char, float, double и boolean. Они делятся на две категории: логическую и числовую. Последняя может быть разделена на целые числа и числа с плавающей точкой.

Целые типы данных Java представляют собой числовые типы, значения которых являются целыми числами. Их пять: byte, short, int, long и char.

Int

Int представляет собой 32-разрядный знаковый примитивный тип данных. Переменная занимает 32 бита памяти. Допустимый диапазон - от -2147483648 до 2147483647 (-2 31 до 2 31 - 1). Все целые числа в этом диапазоне являются целочисленными литералами или константами. Например, 10, -200, 0, 30, 19 являются литералами int. Их можно присвоить переменной int:

• int num1 = 21;

Целые литералы могут быть выражены в виде двоичного, восьмеричного, десятичного и шестнадцатеричного числа.

Когда литерал начинается с нуля и имеет, по крайней мере, две цифры, он считается записанным в восьмеричном формате. 0 и 00 представляют одинаковое значение - ноль.

Все литералы int в формате шестнадцатеричного числа начинаются с 0x или 0x, и они должны содержать хотя бы одну шестнадцатеричную цифру:

• int num1 = 0x123.

Int-литералы в формате начинаются с 0b или 0B:

• int num1 = 0b10101.

Long

Это 64-разрядный знаковый примитивный тип. Используется, когда результат вычислений может превышать диапазон int. Диапазон long - от -2 63 до 2 63 - 1. Все целые числа этого диапазона являются литералами длинного типа.

Чтобы отличать в языке Java типы данных int и long, литерал последнего типа всегда заканчивается L или l.

Целые литералы длинного типа также могут быть выражены в восьмеричном, шестнадцатеричном и двоичном форматах.

Когда long-литерал присваивается переменной long, компилятор Java проверяет присваиваемое значение и удостоверяется, что оно находится в приемлемом диапазоне; в противном случае произойдет ошибка компиляции.

Поскольку диапазон int меньше, чем у long, значение int-переменной всегда может быть присвоено переменной типа long. Но обратное присвоение невозможно даже в пределах диапазона int. Для этого используется явное указание:

• num1 = (int) num2;

Byte

Byte представляет собой 8-разрядный целый примитивный тип. Его диапазон - от -128 до 127 (-2 7 до 2 7 - 1). Это наименьший целый тип, имеющийся в Java. Как правило, байтовые переменные используются, когда в программе задействовано много значений в диапазоне от -128 до 127, или при работе с бинарными данными. В отличие от литералов int и long, byte-литералы отсутствуют. Тем не менее можно назначить byte-переменной любой int-литерал, так как он перекрывает диапазон байта.

Если значение переменной выходит за пределы диапазона, Java выдаст ошибку компилятора.

Кроме того, можно присвоить только int-литерал, но не значение, хранящееся в переменной int, так как при этом возможна потеря точности. Для этого потребуется явное приведение типа.

• b1 = (byte) num1.

Short

Представляет собой 16-разрядный знаковый целый примитивный тип данных. Его диапазон - от -32768 до 32767 (или -2 15 до 2 15 - 1).

Как правило, необходимость в коротких переменных возникает, когда программа использует большое количество значений, которые не превышают указанный диапазон. Short-литерал отсутствует, но возможно присвоение любого литерала int в пределах диапазона short. Значение byte-переменной может быть присвоено всегда. Остальные правила присвоения int или long short-переменной такие же, как для byte.

Char

Char является 16-разрядным беззнаковым примитивным типом данных, который представляет символ Юникода. Отсутствие знака означает, что переменная не может иметь отрицательное значение. Диапазон - от 0 до 65535, что совпадает с кодировкой набора символов Юникода. Литерал представляет значение char и может быть выражен в таких формах:

• символ, заключенный в одинарные кавычки;
• последовательность управляющих символов;
• последовательность управляющих символов юникода;
• последовательность восьмеричных управляющих символов.

Символ может быть выражен путем заключения его в одинарные кавычки: char C1 = "A". обозначают строковый литерал, который не может быть присвоен char-переменной, даже если строка состоит только из одного символа. Это недопустимо, так как ссылка примитивной переменной не присваивается. Все строковые литералы являются объектами класса String и, следовательно, ссылками, тогда как символьные относятся к примитивному типу.

Литерал, выраженный управляющей последовательностью, записывается в виде обратной косой черты с символом в одиночных кавычках. Всего их 8: ‘\n’, ‘\r’, ‘\f’, ‘\b’, ‘\t’, ‘\\’, ‘\”’, ‘\’’.

Управляющая юникод-последовательность имеет вид "\uxxxx", где \u (обратный слеш, за которым следует строчная u) обозначает ее начало, а хххх представляет ровно четыре шестнадцатеричные цифры кода символа в системе Юникод. Например, "A" имеет значение 65 в десятичной системе и 41 в шестнадцатеричной. Таким образом, этот символ может быть представлен как "\u0041".

Восьмеричная управляющая последовательность записывается в виде "\nnn", где n - восьмеричная цифра (0-7). Диапазон значений - от "\000" до "\377", где 377 8 соответствует 255 10 . Поэтому она используется для представления символов с кодом от 0 до 255, необходимого для совместимости с другими языками программирования. В отличие от юникод-последовательности, где необходимы все четыре шестнадцатеричные цифры, здесь можно использовать 1, 2 или 3 восьмеричные: "\n", "\nn" или "\nnn".

Логический тип

Boolean имеет только два действительных значения: true (истина) и false (ложь). Они называются булевыми литералами. Логическая переменная не может быть приведена к другому типу и наоборот. Java не определяет размер boolean - он зависит от конкретной реализации виртуальной Java- машины.

Типы данных Java с плавающей точкой

Число, которое содержит дробную часть, в памяти компьютера может храниться в представлении с фиксированным количеством цифр до и после точки или с указанием ее положения. Так как количество цифр может меняться, то говорят, что точка «плавает».

В языке Java типы данных с плавающей точкой используют 32 бита. Согласно стандарту IEEE 754, это соответствует одинарной точности, которая позволяет представлять, например, числа 1,4 х 10 -45 и 3,4 х 10 38 , причем как положительные, так и отрицательные.

Все которые заканчиваются на f или F, называются float-литералами. Они могут быть представлены в формате десятичного числа и в виде научной нотации. Например:

• float f1 = 3.25F;
• float f2 = 32.5E-1F;
• float f3= 0.325E + 1F.

Тип определяет два нуля: +0.0F (или 0.0F) и -0.0F. Однако для целей сравнения оба нуля считаются равными. Кроме того, им определены два вида бесконечности: положительная и отрицательная. Результаты некоторых операций (например, не определены и представлены специальным значением NaN.

Двойная точность

Для хранения чисел с плавающей точкой double использует 64 бита. Число двойной точности может представлять положительные и отрицательные значения величиной 4,9 х 10 -324 и 1,7 х 10 308 .

Все действительные числа по умолчанию являются двойными литералами. По желанию могут явно обозначаться суффиксом d или D, например, 19.27d. Двойной литерал может быть выражен в десятичной форме и в научной нотации.

Переменная - это основной элемент хранения информации в Java- программе. Переменная характеризуется комбинацией идентификатора, типа и области действия. В зависимости от того, где объявлена переменная, она может быть локальной, например, для кода внутри метода, либо это может быть переменная экземпляра класса, доступная всем методам данного класса. Локальные области действия объявляются с помощью фигурных скобок.

1.1. Объявление переменных

Все переменные должны быть объявлены до первого их использования в программе. Основная форма объявления переменной такова:

тип идентификатор [ = значение] [, идентификатор [ = значение ]...];

Тип - это либо один из встроенных типов, либо имя класса или интерфейса. Ниже приведено несколько примеров объявления переменных различных типов. Обратите внимание на то, что некоторые примеры включают в себя инициализацию начального значения. Переменные, для которых начальные значения не указаны, автоматически инициализируются нулем.

Таблица 1.1. Объявление переменных различных типов

		Вид переменной
	int а, b, с;	Объявляет три целых переменных а, b, с
	int d = 3, е, f = 5;	Объявляет еще три целых переменных, инициализирует d и f
	byte z = 22;	Объявляет переменную z типа byte и инициализирует ее
	double pi = 3.14159;	Объявляет переменную pi типа double и инициализирует ее числом пи
	char x = "x";	Символьная переменная х получает значение "х"

Идентификатор – это наименование переменной. В качестве идентификатора может использоваться любая последовательность строчных и прописных букв, цифр и символов _ (подчеркивание) и $ (доллар). Идентификаторы не должны начинаться с цифры.

Значение - это любой литерал или выражение, результатом которого является значение того же (или совместимого с указанным в объявлении переменной) типа. В приведенном ниже примере создаются три переменные, соответствующие сторонам прямоугольного треугольника, а затем с помощью теоремы Пифагора вычисляется длина гипотенузы, в данном случае числа 5, величины гипотенузы классического прямоугольного треугольника со сторонами 3-4-5.

class Variables {
public static void main (String args ){
double a = 3;
double b = 4;
double c;
с = Math.sqrt (a* a + b* b);
System.out.println ("c = "+ c);
}

1.2. Область видимости переменной

Блоки составных операторов в Java отмечаются парой фигурных скобок {}. Переменные в Java начинают действовать с того места в программе, где они объявлены до конца содержащего их блока. Блоки могут быть вложены друг в друга, и у каждого может быть свой собственный набор локальных переменных.

Java — строготипизованный язык. Это означает, что каждая переменная и каждое выражение Java должно иметь тип , определенный уже на этапе компиляции. Каждый тип имеет определенный диапазон значений и определяет набор применимых к нему операций и их смысл. Строгая типизация помогает обнаруживать ошибки в программе на этапе компиляции.

Все типы в Java подразделяются на примитивные и ссылочные . Примитивными являются логический тип boolean , целые числовые типы byte , short , int , long , char и плавающие числовые типы float и double . К ссылочным типам относятся классы , интерфейсы и массивы . Существует также специальный нулевой тип .

Объект в Java — это или динамически созданный экземпляр класса, или динамический созданный массив. Значениями ссылочного типа являются ссылки на объекты. Все объекты, включая массивы, наследуют методы класса Object . Строки представляются объектами класса String .

Переменная — это именованное хранилище данных определенного типа. Точнее говоря:

• Переменная примитивного типа всегда содержит значение именно этого типа.
• Переменная типа класс может содержать либо значение null (нулевую ссылку), либо ссылку на объект данного класса или его наследника.
• Переменная типа интерфейс может содержать либо нулевую ссылку, либо ссылку на объект любого класса, реализующий данный интерфейс.
• Переменная типа " array of T ", где T — примитивный тип, может содержать либо нулевую ссылку, либо ссылку на объект типа " array of T ".
• Переменная типа " array of T ", где T — ссылочный тип, может содержать либо нулевую ссылку, либо ссылку на массив, состоящий из данных, совместимых с T по присваиванию.
• Переменная типа Object может содержать либо нулевую ссылку, либо ссылку на любой объект.

5.3.2. Примитивные типы

5.3.2.1. Тип boolean

Тип boolean состоит из двух логических констант: true (истина) и false (ложь). Логическое значение может быть приведено к типу boolean , другие неявные приведения к данному типу в Java отсутствуют. Логическое значение может быть преобразовано в строку по правилу неявного преобразования строк.

Пример декларации логической переменной:

Помните, что на один объект может указывать любое количество ссылок. Если две переменные указывают на один объект, то состояние объекта может быть изменено через первую ссылку, а затем прочитано через вторую.

5.3.3.2. Класс Object

Стандартный класс Object является предком всех остальных классов Java, которые наследуют его методы. Подробно эти методы описаны в гл. 5.14 .

5.3.3.3. Класс String

Экземплярами класса String являются текстовые строки, т. е. цепочки символов Unicode. Объект класса String имеет постоянное (неизменяемое) значение. Строковые константы являются ссылками на экземпляры класса String .

Оператор конкатенации строк неявно создает новый объект класса String .

5.3.4. Переменные

Переменная — это хранилище данных определенного типа, обычно имеющее уникальное имя. Переменная всегда содержит значение, которое совместимо по присваиванию с ее типом. Значение переменной изменяется операцией присваивания или операциями префиксного/постфиксного инкремента/декремента.

5.3.4.1. Виды переменных

В Java существуют семь разновидностей переменных:

1. Переменная класса — это статическое поле данных в декларации класса или любое поле данных в декларации интерфейса. Переменная класса создается при загрузке ее класса или интерфейса; сразу после создания ей присваивается значение по умолчанию. Переменная класса уничтожается, когда ее класс или интерфейс выгружается (после завершения его финализации).
2. Переменная реализации — это поле данных в декларации класса, которое не является статическим. Такая переменная создается и получает значение по умолчанию при создании экземпляра данного класса или класса, который является его потомком. Переменная реализации уничтожается, когда соответствующий экземпляр класса удаляется процедурой сборки мусора (после завершения его финализации).
3. Элементы массива — это неименованные переменные, которые создаются и получают значение по умолчанию при создании массива. Эти переменные уничтожаются, когда массив удаляется процедурой сборки мусора.
4. Параметры конструктора — это имена значений аргументов, передаваемых конструктору. Для каждого параметра в декларации конструктора создается новая переменная каждый раз, когда вызывается данный конструктор (явно или неявно). Этой переменной присваивается фактическое значение аргумента, переданное конструктору при вызове. Переменная уничтожается после завершения выполнения тела конструктора.
5. Параметры метода — это имена значений аргументов, передаваемых методу. Для каждого параметра в декларации метода создается новая переменная каждый раз, когда вызывается данный метод. Этой переменной присваивается фактическое значение аргумента, переданное методу при вызове. Переменная уничтожается после завершения выполнения тела метода.
6. Параметр обработчика исключений создается всякий раз, когда выполняется часть catch оператора try . Его значением становится объект, ассоциированный с возникшим исключением. Переменная уничтожается после завершения выполнения блока catch .
7. Локальные переменные . Каждый раз, когда в ходе выполнения программы управление передается новому блоку или оператору for , для каждой декларации переменной внутри этого блока или оператора создается соответствующая локальная переменная. Если декларация содержит начальное значение переменной, то ей присваивается это значение. Локальная переменная уничтожается после завершения выполнения блока или оператора, в котором она объявлена.

Следующий пример содержит декларации нескольких переменных перечисленных разновидностей:

Class Point { static int numPoints; // numPoints - переменная класса int x, y; // x и y - переменные реализации int w = new int; // w - массив целых чисел, w - элемент массива int setX(int x) { // x - параметр метода int oldx = this.x; // oldx - локальная переменная this.x = x; return oldx; } }

5.3.4.2. Начальные значения переменных

Перед тем, как к переменной можно будет обращаться, ей должно быть присвоено значение. При этом

• Каждой переменной класса, переменной реализации и каждому элементу массива при создании присваивается значение по умолчанию следующим образом:
• переменные типов byte , short , int , long получают значение 0 соответствующего типа;
• переменные типов float и double получают значение +0 соответствующего типа;
• переменные типа char получают значение "\u0000";
• переменные типа boolean получают значение false ;
• переменные ссылочных типов получают значение null ;
• Каждому параметру метода и конструктора присваивается фактическое значение соответствующего аргумента, определенное в момент вызова данного метода или конструктора.
• Параметр обработчика исключений инициализируется соответствующим объектом.
• Локальной переменной перед ее использованием должно быть присвоено значение либо инициализацией в декларации, либо оператором присваивания.

Java является объектно-ориентированным языком, которому свойственна абстракция, однако для прикладных задач всегда приходится оперировать известными параметрами. В программировании они называются переменными. Чем java переменная отличается от объекта?

Всё просто – переменная является ячейкой в памяти, где хранится её значение. Любое действие – прямая работа с этим участком памяти. Объект же является более комплексной величиной. Он занимает определённый диапазон памяти, взаимодействие осуществляется через некую передаточную функцию (методы), выраженную в параметрах объекта.
В данной статье мы поговорим именно о переменных, здесь это совсем не тривиальное понятие.

Объявляются переменные java так:

тип_данных имя_переменной;

Здесь же при объявлении можно присвоить значение.

тип_данных имя_переменной = значение_переменной;

Также можно объявить одновременно несколько переменных, просто перечисляя их через запятую.

тип_данных имя_переменной1, имя_переменной2…;

Классификация по принадлежности

Выделяется четыре типа java переменных:

• переменные экземпляра (instance variables);
• переменные класса (class variables);
• локальные переменные (local variables);
• параметры (parameters).

Пусть у нас есть несколько объектов одного класса Automobile(). Помимо общих параметров у них есть уникальные, скажем, максимальная скорость maxSpeed(). Их можно инициировать в теле программы, а можно хранить в нестатических полях класса (объявленных без добавления слова static). Таким образом, каждый экземпляр будет обладать индивидуальным параметром, не зависящим от скоростей других объектов.

public class Automobile { public String name; private double maxSpeed ; public Automobile (String autoName ){ name = autoName; }}

Переменная класса, или статическая переменная java, напротив, объявляется исключительно с применением слова static. В данном случае её значение будет одинаковым для всех экземпляров. В случае того же автомобиля, введём параметр gearsNum – число передач. Для всех экземпляров оно будет равно 6.

Необязательный модификатор final позволяет присвоить значение переменной только один раз. За соблюдением этого следит компилятор.

public class Automobile { public String model ; private double maxSpeed ; public static final int gearsNum = 6 ; }

Локальные переменные и методы в java неизменно связаны. В последних часто фигурируют вспомогательные параметры, которые в дальнейшем коде не нужны. Для объявления локальной переменной нет особой формы инициализации, границы её действия зависят лишь от места объявления. В данном случае - в фигурных скобках внутри метода. При выходе из него переменная будет уничтожена, поэтому обратиться к ней будет уже нельзя.

Крайний случай локальных переменных - это параметры. В частности, классический пример «Hello, World!»:

class HelloWorld { public static void main (String args ) { System . out. println("Hello World!" ); } }

Здесь сразу два параметра. Первая - собственно, «Hello, World!», вторая - аргумент строки args в main.

Классификация по видимости

На основании описанного выше, можно проследить ещё одно деление – по видимости переменных. Существует 4 группы:

• Public. Данный модификатор переменных доступен всем классам и объектам программы. Объявляется при помощи ключевого слова public в начале строки.
• Protected. Области видимости java переменных в этом случае ограничены текущим пакетом и подклассами. Объявляется аналогично - ключевым словом protected.
• Package protected. Модификатор переменных, доступных только внутри пакета. Объявления не требуется, отсутствие ключевых слов указывает на package protected.
• Private. Переменные, доступные исключительно внутри класса. В данном случае, определить тип переменной можно по ключевому слову private.

Несмотря на то, что приватные элементы доступны внутри класса, вопрос: «как обращаться к private java переменным?» всё же имеет ответ. Для того, чтобы иметь возможность извне поменять значение приватного параметра, достаточно внутри того же класса создать публичный метод. Например так:

class Drive { private int gears; public void setGears (int val ) { gears = val; } }

Таким образом, в случае необходимости вы легко сможете изменить значение private переменной.

Указатели - ещё один вариант глобальных переменных. Вспомните, для создания экземпляра объекта мы используем следующую запись:

класс_объекта имя_указателя = new класс_объекта;

Такие переменные называются ссылочными переменными.