Сайт о телевидении

What is a Variable?

A variable can be thought of as a container which holds value for you, during the life of a Java program. Every variable is assigned a data type which designates the type and quantity of value it can hold.

In order to use a variable in a program you to need to perform 2 steps

1. Variable Declaration
2. Variable Initialization

In this tutorial, you will learn-

Variable Declaration:

To declare a variable, you must specify the data type & give the variable a unique name.

Examples of other Valid Declarations are

Int a,b,c; float pi; double d; char a;

Variable Initialization:

To initialize a variable, you must assign it a valid value.

Example of other Valid Initializations are

Pi =3.14f; do =20.22d; a=’v’;

You can combine variable declaration and initialization.

Int a=2,b=4,c=6; float pi=3.14f; double do=20.22d; char a=’v’;

Types of variables

In Java, there are three types of variables:

1. Local Variables
2. Instance Variables
3. Static Variables

1) Local Variables

Local Variables are a variable that are declared inside the body of a method.

2) Instance Variables

Instance variables are defined without the STATIC keyword .They are defined Outside a method declaration. They are Object specific and are known as instance variables.

3) Static Variables

Static variables are initialized only once, at the start of the program execution. These variables should be initialized first, before the initialization of any instance variables.

Example: Types of Variables in Java

class Guru99 { int data = 99; //instance variable static int a = 1; //static variable void method() { int b = 90; //local variable } }

Data Types in Java

Data types classify the different values to be stored in the variable. In java, there are two types of data types:

1. Primitive Data Types
2. Non-primitive Data Types

Primitive Data Types

Primitive Data Types are predefined and available within the Java language. Primitive values do not share state with other primitive values.

There are 8 primitive types: byte, short, int, long, char, float, double, and boolean Integer data types

Byte (1 byte) short (2 bytes) int (4 bytes) long (8 bytes)

Floating Data Type

Float (4 bytes) double (8 bytes)

Textual Data Type

Char (2 bytes)

Boolean (1 byte) (true/false)

Data Type	Default Value	Default size
byte	0	1 byte
short	0	2 bytes
int	0	4 bytes
long	0L	8 bytes
float	0.0f	4 bytes
double	0.0d	8 bytes
boolean	false	1 bit
char	"\u0000"	2 bytes

Points to Remember:

• All numeric data types are signed(+/-).
• The size of data types remain the same on all platforms (standardized)
• char data type in Java is 2 bytes because it uses UNICODE character set. By virtue of it, Java supports internationalization. UNICODE is a character set which covers all known scripts and language in the world

Java Variable Type Conversion & Type Casting

A variable of one type can receive the value of another type. Here there are 2 cases -

Case 1) Variable of smaller capacity is be assigned to another variable of bigger capacity.

This process is Automatic, and non-explicit is known as Conversion

Case 2) Variable of larger capacity is be assigned to another variable of smaller capacity

In such cases, you have to explicitly specify the type cast operator. This process is known as Type Casting.

In case, you do not specify a type cast operator; the compiler gives an error. Since this rule is enforced by the compiler, it makes the programmer aware that the conversion he is about to do may cause some loss in data and prevents accidental losses.

Example: To Understand Type Casting

Step 1) Copy the following code into an editor.

Class Demo { public static void main(String args) { byte x; int a = 270; double b = 128.128; System.out.println("int converted to byte"); x = (byte) a; System.out.println("a and x " + a + " " + x); System.out.println("double converted to int"); a = (int) b; System.out.println("b and a " + b + " " + a); System.out.println("\ndouble converted to byte"); x = (byte)b; System.out.println("b and x " + b + " " + x); } }

Step 2) Save, Compile & Run the code.

Int converted to byte a and x 270 14 double converted to int b and a 128.128 128 double converted to byte b and x 128.128 -128

Примитивные типы в Java — важная, часто используемая часть языка, которая требует особого обращения. В этой публикации попробуем ответить на все вопросы связанные с примитивными типами, механизмом их работы, обработкой. Статья предназначена как для новичков, которые только стали на тернистый путь изучения Java (к ним отношусь и я), так и для людей, достаточно знакомым с языком, которые смогут освежить знания и, надеюсь, найдут что-то интересное для себя.

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

Примитивные типы немного нарушают объектную ориентированность языка Java, так так представляют одиночные (простые) значения. Эта особенность объясняется желанием обеспечить максимальную эффективность. Создавать объект простой переменной с помощью new недостаточно эффективно, так как new перемещает объект в кучу. Вместо этого создается «автоматическая» переменная, которая не является ссылкой на объект. Переменная хранит единственное значение и располагается в стеке. Стек — это область хранения данных, расположена в RAM. Процессор имеет прямой доступ до этой области через указатель на стек, поэтому стек — очень быстрый и эффективный способ хранения данных. По скорости стек уступает только регистрам (логично, так как регистры расположены внутри процессора).
Все размеры примитивных типов строго фиксированы и не зависят от машинной архитектуры. Это одна с причин улучшенной переносимости Java-программ.
В Java определено восемь примитивных типов, которые можно разбить на четыре группы:

Целые числа

Для целых чисел определены четыре примитивных типа: byte , short , int , long . Все эти типы представляют целочисленные значения со знаком: положительные или отрицательные. В Java нет положительных целочисленных значений без знака (unsigned ). Как было сказано раньше, все размеры примитивных типов фиксированы:
Наименьшим целочисленным типом является byte . Переменные этого типа очень удобны для работы с потоками ввода-вывода и при манипулировании двоичными данными. Далее идет тип short , который применяется реже всех остальных типов. Наиболее часто употребляемым типом является int . Его постоянно используют в циклах, для индексации массивов. Может показаться, что использование типов byte и short в местах, где не требуется широкий диапазон значений, будет более эффективным чем использование int . Но это не так, потому что при вычислении выражений значения типа byte или short будут преобразованы в int (мы еще вернемся к этому вопросу). Когда длины типа int недостаточно для хранения значения, нужно использовать long . Его диапазон значений достаточно велик, что делает long удобным при работе с большими целыми числами.

Числа с плавающей точкой

Числа с плавающей точкой (или действительные числа) представлены типами float и double . Используются для хранения значений с точностью до определенного знака после десятичной точки.
Тип float определяет числовое значение с плавающей точкой одинарной точности. Этот тип используется, когда нужно числовое значение с дробной частью, но без особой точности. Тип double используется для хранений значений с плавающей точкой двойной точности. Обработка значений двойной точности выполняется быстрее, чем обработка значений одинарной точности. Поэтому большинство математических функций класса java.lang.Math возвращают значения типа double . Эффективнее всего использовать double , когда требуется сохранить точность многократно повторяющихся вычислений или манипулировать большими числами.

Символы

В спецификации примитивный тип char принадлежит к целочисленным типам (или integral types ), но поскольку он играет немного другую роль, можно выделить для него собственную категорию. Его роль — представлять символы Unicode . Для хранения символов требуется 16 бит. Странно, ведь для представления символов основных языков (например, английского, французского, испанского) достаточно 8 бит. Но такая цена интернационализации. Unicode использует полный набор международных символов на всех известных языках мира.

Логические азначения

Примитивный тип boolean предназначен для хранения логических значений. Данный тип может принимать одно из двух возможных значений: true (истина) или false (ложь). Значения boolean возвращаются со всех логических операций (например, операции сравнения). Является обязательным при построении циклов, операторов (например, for, if).

Литералы

Значения примитивных типов данных в большинстве случаев инициализируются с помощью литералов. Рассмотрим их.

Целочисленные литералы

Наиболее часто используемые литералы. Любое целочисленное значение является числовым литералом (например, -10 , 10 — десятичные значения). Можно использовать восьмеричные, шестнадцатеричные и двоичные литералы:

// десятичный литерал, числа , не начинается с 0 int decimal = 10; // 10 // восьмеричный литерал начинается с 0, далее числа int octal = 010; // 8 // шестнадцатеричный литерал начинается с 0x или 0Х, далее числа и символы int hexadecimal = 0x10; // 16 // двоичный литерал начинается с Оb или 0B, далее числа int binary = 0b10; // 2
Все целочисленные литералы представляют значения int . Если значение литерала лежит в диапазоне byte , short или char , то его можно присвоить переменной этого типа без приведения типов. Для создания литерала типа long , необходимо явно указать компилятору, дополнив литерал буквой "l " или "L ":

Byte b1 = 127; byte b2 = 128; // ошибка short s1 = -32768; short s2 = -32769; // ошибка char c1 = 0; char c2 = -1; // ошибка long l1 = 10l; long l2 = 0x7fffffffffffffffL; // максимальное значение типа long

Литералы с плавающей точкой

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

// стандартная форма double d1 = 0.; // эквивалентно.0 или 0.0; double d2 = 0.125; // экспоненциальная форма - используется символ "e" или "E" // после него степень числа 10, на которую следует умножить данное число double d3 = 125E+10; // если степень положительная, "+" можно упустить double d4 = 1.25e-10;
Всех литералам с плавающей точкой по-умолчанию присваивается тип double . Поэтому чтобы создать литерал типа float , нужно после литерала указать букву "f " или "F ". К литералам также можно добавлять букву "d " или "D ", сообщая, что это литерал типа double, но зачем?

Double d1 = 0.125; float f2 = 0.125f;
Можно использовать шестнадцатеричные литералы с плавающей точкой, например:

// P - двоичный порядок, что обозначает степень числа 2, на которое следует умножить данное число double d = 0x10.P10d; // конечно, можно и без "d" float f = 0x20.P10f;
Для удобности чтения длинных литералов в 7 версии языка была добавлена возможность использовать символ "_" внутри литерала:

// можно делать любые комбинации с использованием любого количества символов "_" int phone = 111__111__111; int bin = 0b1000_1000_1000; double dollars = 23_000.450__500; // не допускается использовать символ "_" в конце или начале литерала, также не можно разрывать "0x" и "0b"

Символьные литералы

Символьные литералы заключаются в одинарные кавычки. Все отображаемые символы можно задавать таким способом. Если символ нельзя ввести непосредственно, используют управляющее последовательности начинающиеся с символа "\ ". Хотя все эти последовательности можно заменить соответствующим Unicode кодом. Также символьный литерал можно создать используя восьмеричную ("\xxx") и шестнадцатеричную форму ("\uxxxx").

Char h = "a"; // стандартная форма char a = "\001"; // восьмеричная форма char c = "\u0001"; // шестнадцатеричная форма
Существуют также строковые литералы. Информацию о них можно получить .

Логические литералы

С логическими операторами все просто. Существует только два логических литерала:

Boolean yes = true; // истина boolean no = false; // ложь
Логические литералы можно присваивать только переменным типа boolean . Также важно понимать, что false не равен 0 , а true не равен 1 . Преобразовать переменную типа boolean в другие примитивные типы не выйдет.

Операции

Над целочисленными типами

• операторы сравнения (> , < , >= , <= ) и равенства (== , != )
• унарные операторы (+ , - )
• мультипликативные (* , / , % ) и аддитивные (+ , - ) операторы
• инкремент (++ ) и декремент (-- ) в префиксной и постфиксной формах
• знаковые (>> , << ) и без знаковые (>>> ) операторы сдвига
• побитовые операторы (~ , & , ^ , | )
• условный оператор (? : )
• оператор приведения типов

Над Floating-Point типами

Над числами с плавающей точкой можно проводить все те же операции, что и с целыми числами, за исключением побитовых операторов и операторов сдвига.

Над логическим типом

• операторы равенства (== и != )
• логические операторы (! ,& , | , ^ )
• условные логические операторы (&& , || )
• условный оператор (? : )

Преобразование

Существует три типа преобразований:

• расширяющее преобразование (widening )
• суживающее преобразование (narrowing )
• widening + narrowing (преобразование byte к char , сначала byte преобразовываем в int , а потом int — в char )

Расширяющее преобразование

Если оба типа совместимы и длина целевого типа больше длины исходного типа выполняется расширяющее преобразование (например byte преобразуется в int ). Следующая таблица демонстрирует все возможные расширяющее преобразования. Курсовом помечены типы, преобразования в которые, возможно, приведут к потери данных.

Суживающее преобразование

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

short	byte, char
char	byte, short
int	byte, short, char
long	int, byte, short, char
float	long, int, byte, short, char
double	float, long, int, byte, short, char

Чтобы выполнить преобразование двух несовместимых типов необходимо воспользоваться приведением (casting ). Если значения исходного целочисленного типа больше допустимого диапазона значений целевого типа, то оно будет сведено к результату деления по модулю на диапазон целевого типа. Если же значения типа с плавающей точкой приводится к значению целочисленного типа, то происходит усечение (отбрасывается дробная часть).

Byte a = (byte)128; // - 128 byte b = (byte)42; // привидение возможно, но, в данном случаи, в нем нет необходимости int i1 = (int)1e20f; // 2147483647 int i2 = (int)Float.NaN; // 0 float f1 = (float)-1e100; // -Infinity float f2 = (float)1e-50; // 0.0

Продвижение

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

Int a = 100; float b = 50.0f; double c = 50.0; double result = a - b + c; // 100.0 // на самом деле: result = (double)((float)a - b) + c;
Правила продвижения хорошо демонстрирует следующая диаграмма:

Классы-обертки

Для представления примитивных типов как объектов было сделаны классы-обертки (wrapper classes ). Какие преимущества дают нам классы-обертки?

• возможность использования объектов классов-оберток в качестве параметров к методам или как generic-параметры
• возможность использования констант, которые отвечают за границы соответствующего типа данных (MIN_VALUE и MAX_VALUE )
• возможность использования методов для преобразования в другие примитивные типы, конвертации между системами счисления

Wrapper-классов восемь, по одному на каждый примитивный тип:
Почти все классы (кроме Boolean и Character ) унаследованы от абстрактного класса Number и являются сравнимыми (реализуют интерфейс Comparable ). Иерархия, примерно, такая:

// существует несколько способов создания Integer i1 = new Integer("10"); Integer i2 = new Integer(10); Integer i3 = Integer.valueOf(10); Integer i4 = Integer.valueOf("10", 10); // можно указать систему счисления, только для оберток целочисленных примитивных типов Character c1 = new Character("c"); // тут только один способ // получаем значения примитивных типов int i5 = i1.intValue(); char c2 = c1.charValue();

Автоупаковка и распаковка

В версии JDK 5 были введены два важных средства:

• Автоупаковка (autoboxing ) — процесс автоматического инкапсулирования примитивного типа в соответствующий класс-обертку. Отпадает необходимость явно создавать объект.
• Распаковка (unboxing ) — процесс автоматического извлечения примитивного типа с соответствующего класса-обертки. Отпадает необходимость явного вызова метода для получения примитивного типа.

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

Public static void main(String... s) { Integer i1 = 10; // автоупаковка - Integer.valueOf(10) int i2 = i1; // распаковка - i1.intValue() method(10); // автоупаковка в объект класса Integer - Integer.valueOf(10) ++i1; // распаковка - i1.intValue(), автоупаковка - Integer.valueOf(i1.intValue() + 1) } private static int method(Integer i) { return i; // распаковка объекта, принятого как параметр - i.intValue() }

Некоторые полезные методы

Integer i1 = 128; i1.compareTo(5); // 1, то есть i.intValue() > Integer.valueOf(5) Integer.decode("0xabc"); // не работает с двоичными литералами Integer.parseInt("10", 3); // работает с любой системой счисления // метод преобразования i1.byteValue(); // (byte)i.intValue() // методы проверки Float f = 20.5f; Boolean badFloat = f.isInfinite() || f.isNaN(); // false, автоупаковка boolean // преобразование в строку f.toString();
Спасибо за внимание. Все дополнения, уточнения и критика приветствуются.

Переменная - это основной элемент хранения информации в 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 начинают действовать с того места в программе, где они объявлены до конца содержащего их блока. Блоки могут быть вложены друг в друга, и у каждого может быть свой собственный набор локальных переменных.

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

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 подразделяются на примитивные и ссылочные . Примитивными являются логический тип 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 ;
• Каждому параметру метода и конструктора присваивается фактическое значение соответствующего аргумента, определенное в момент вызова данного метода или конструктора.
• Параметр обработчика исключений инициализируется соответствующим объектом.
• Локальной переменной перед ее использованием должно быть присвоено значение либо инициализацией в декларации, либо оператором присваивания.