Инициализация переменной java. Автоупаковка и распаковка. Область видимости переменной

Мы уже и использовали переменные в наших примерах, поскольку без них было бы очень затруднительно объяснить примитивные типы данных в Java, но не акцентировали на этом внимания, так как это не большая и не сложная тема. О константах в Java мы вообще пока не говорили. И вот настало время! Ну погнали!

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

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

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

• тип — это один из элементарных типов Java либо имя класса или интерфейса.
• идентификатор — это имя переменной

Переменной можно присвоить начальное значение (инициализировать ее), указывая знак равенства и значение. Следует помнить, что выражение инициализации должно возвращать значение того же (или совместимого) типа, который указан для переменной. Для объявления более одной переменной указанного типа можно использовать список с разделителями-запятыми.

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

a , b , c ; // объявление трех переменных типа int: a, b и c
int d = 3 , e , f = 5 ; // объявление еще трех переменных типа int с инициализацией d и f
byte z = 22 ; // инициализация переменной z
double pi = 3.14159 ; // объявление приблизительного значения переменной pi
char x = "x" ; // присваивание значения "x" переменной x

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

vacationDays ;
System . out . println ( vacationDays ) ; // ОШИБКА! Переменная не инициализирована

Как правильно именовать переменные мы уже обсуждали.

Динамическая инициализация переменных

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

a = 3.0 , b = 4.0 ;
// динамическая инициализация переменной c
double c = Math . sqrt ( a * a + b * b ) ;
System . out . println ( "Гипотенуза равна " + c ) ;

Область действия и время существования переменных

Это достаточно важный вопрос и его надо рассмотреть поподробнее. И для этого сперва надо рассмотреть использование блоков кода в Java.

Использование блоков кода

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

( x < y ) { // начало блока
x = y;
y = 0 ;
} // конец блока

В этом примере, если x меньше y, программа выполнит оба оператора, расположенные внутри блока. Таким образом, оба оператора внутри блока образуют логический модуль, и выполнение одного оператора невозможно без одновременного выполнения и второго. Основная идея этого подхода состоит в том, что во всех случаях, когда требуется логически связать два или более оператора, это делается посредством создания блока.

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

Основное правило, которое следует запомнить: переменные, объявленные внутри области действия, не видны (т.е. недоступны) коду, который находится за пределами этой области. Таким образом, объявление переменной внутри области действия ведет к ее локализации и защите от несанкционированного доступа и/или изменений.

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

Переменная y , определенная внутри своей области действия ограниченной фигурными скобками, доступна только в ней. За ее пределами переменная y уже не доступна, а переменная x доступна, и во области действия переменной y .

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

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

Хотя блоки могут быть вложенными, во внутреннем блоке нельзя объявлять переменные с тем же именем, что и во внешней области .

Код приведенный на примере слева, выдаст ошибку компиляции.

Такие трюки возможные в C и C++ в Java не проходят.

Константы в Java

В Java для обозначения констант служит ключевое слово final . Ключевое слово final означает, что присвоить данной переменной какое-нибудь значение можно лишь один раз, после чего изменить его уже нельзя. Рекомендуется использовать для именования констант прописные буквы, хоть это и не является обязательным, но такой стиль способствует удобочитаемости кода. Пример объявления константы:

double CM_PER_INCH = 2.54 ;

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

Часто Вы можете услышать такое определение переменной:

• Переменная - это некоторый контейнер, в котором может храниться значение для дальнейшего использования в программе.

Помните, как в школе было: y = x + 1

И в зависимости от того, какие значения принимает переменная x, меняется значение переменной y.

Если x = 1, тогда x+ 1 =2

Если x = 2, тогда x +1 = 3

Если х = 1.5 , тогда x + 1 =2.5

В Java переменные играют такую же роль, как и в приведенном примере со школы y = x + 1. Они выполняют роль контейнера для разных значений, которые можно подставить в переменную. В приведённом примере - в переменную x.

Типы переменных в Java. Объявление переменной

В Java можно указать, какие именно значения может принимать переменная.

Для этого все переменные сгруппировали в 4 группы:

1. Символы (char)
2. Логические (boolean)

Примечание: Итого 8 типов переменных (byte, short, int, long, float, double, char, boolean). Многоуважаемый Брюс Эккель выделяет еще и 9-й тип – так называемый тип void («пустое» значение). Но в этой статье мы рассмотрим 8 типов, как это обычно принято. Что же такое тип void мы разберёмся в теме, посвященной методам в Java.

Теперь давайте рассмотрим каждую группу переменных. И начнём с целочисленных.

Целочисленные: byte, short, int, long

Как видно из таблички, byte, short, int, long относятся к целочисленным, то есть к целым числам. Например, 1, 9, 1278, -5, -107 и т.д.

Очевидно:

1. byte может принимать значения от -128 до 127 и при этом занимает 1 байт памяти
2. short принимает значения от -32768 до 32767 и занимает 2 байта памяти
3. int от -2147483648 до 2147483647 и занимает 4 байта памяти
4. long от -9223372036854775808 до 9223372036854775807 и занимает 8 байтов памяти

"Ну, хорошо", - скажете Вы. "Если byte, short, int и long отвечают все за целые числа, как мне понять какой именно тип нужно выбирать? " Помните детские задачки по математике, которые сейчас будут как нельзя кстати для объяснения за что отвечают byte, short, int, long.

Задача 1:

У Димы 3 яблока, у Ани 2 яблока. Сколько яблок у Димы и Ани вместе?

Как видите, в задаче речь идет о целых яблоках. Не предполагается, что яблоки будут делить на части.

Значит, если бы мы писали код в Java, который бы предполагал решение данной задачи, мы бы использовали для переменных целочисленный тип. Остается понять только какой именно мы бы использовали: byte, short, int или long?

Всегда необходимо отталкиваться от контекста .

1. Если мы знаем точно, что при решении данной задачи, даже если будут меняться значения, например, у Димы 50 яблок, у Ани 30, но в сумме это будет не больше 127 яблок, то можем смело использовать тип byte
2. Если же мы знаем, что могут поменять условия задачи и у Димы может быть, например, 10 000 яблок, а у Ани, например, 7 000 яблок, то уже тип byte мы использовать не можем. Поскольку это явно выходит за пределы допустимых значений в byte – не более 127. Значит, могли бы использовать тип short, у которого максимально допустимое значение 32767

1. Если же предположить, что у Димы и у Ани может быть даже больше, чем 32767 яблок. Ну, например, у них яблоневые сады по всей Украине. Тогда необходимо использовать тип int. Кстати, int – это сокращенно от английского integer (целое число).
2. Ну, а если предположить, что Дима и Аня – это «яблочные магнаты» и им принадлежат все яблоневые сады в мире, то тогда число может быть намного больше, чем даже максимальное значение int 2147483647. И тогда необходимо использовать тип long.

Однако чаще всего при написании программ на Java, Вы будете использовать тип int. Это самый распространенный целочисленный тип. Более того, тип int в Java является типом "по умолчанию" для целочисленных типов. Что это значит, Вы узнаете на практике.

. А объявляются переменные так.

И здесь сразу же хочется сказать о том, что переменные, когда их название состоит из 2 и более слов, пишутся слитно и как бы "горбиками" как у верблюда. Такой стиль написания слов называется CamelStyle (от англ. camel - "верблюд").

Например:

int applesAnnaJune;

int applesDimaJuneUkraine;

Видите, названия примеров переменных состоят из 2 и более слов и пишутся слитно. Причем первое слово пишется с маленькой буквы, а во всех последующих словах первая буква большая. Теперь Вы знаете - это CamelStyle, стиль написания названий. Он иногда называется CamelCase. Мы об этом даже написали 🙂

Ну что ж, самое время понять за что отвечают переменные с плавающей точкой.

С плавающей точкой: float, double

И снова обратимся к примеру школьной задачи.

Задача 2:

У Димы 3,5 яблока, у Ани 2,5 яблока. Сколько яблок у Димы и Ани вместе?

Как видите, в задаче речь идёт уже не о целых яблоках. Уже речь идёт о дробных числах. А значит мы уже не можем использовать целочисленный тип: нам не подойдет ни byte, ни short, ни int, ни long. Запомните: как только речь идет о дробных числах, значит, речь идет о float и ли double. Примеры дробных чисел: 1.0, 1.8, 3.141562, 9.0, 12.579, 1278.0, -5.0, - 9.4, -107.0, -107.356 и т.д.

Как видно из таблички:

1. float может принимать значения от -3.4Е +38 до 3.4Е +38 и при этом занимает 4 байта памяти
2. double принимает значения от -1.7E + 308 до 1.7Е + 308 и занимает 8 байт памяти

Запомните:

• дробные числа пишутся не через запятую, как мы привыкли со школы, а через точку . Например, 1,5 - это неправильно. Правильно 1.5
• float определяет значение одинарной точности. Это значит, что переменные данного типа удобны, когда требуется дробная часть без особой точности. Например, для денежных сумм.
• double обеспечивает двойную точность и это видно из названия (double - двойная).

Прежде, чем использовать переменную, её необходимо объявить . А объявляются переменные float и double по такому же принципу.

А вот и

float money; // объявили переменную money типа float

float wage; // объявили переменную wage типа float

float c; // объявили переменную c типа float

double stat; //объявили переменную stat типа double

Символы: char

В Java для char используется кодировка Unicode. Как видно из таблички, диапазон допустимых значений char от 0 до 65536 и при этом занимает 2 байта памяти. Отрицательных значений не существует. На самом деле переменная типа char хранит не сам символ, а его числовой код из таблички Unicode, по этому мы можем проводить целочисленные операции над символами.

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

Примеры объявления переменных:

char y; //объявили переменную y типа char

char f; //объявили переменную f типа char

Логические: boolean

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

Только у славян возможен такой разговор:

Кушать будешь?

Да нет, наверное.

Это то, что очень удивляет иностранцев, когда они учат, например, украинский или русский язык. Так все-таки да или все-таки нет?

Так вот в языке программирования Java всё очень точно:

• либо true (с английского - "истина")
• либо false (с английского - "ложь)

Чуть позже Вы поймете где применяется данный тип переменных, когда мы, например, дойдём до темы . А пока просто запомните, что есть такой тип. Пусть это будет пока "черной лошадкой" для Вас.

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

Примеры объявления переменных:

boolean check1; //объявили переменную check1 типа boolean

boolean check2; //объявили переменную check2 типа boolean

Ну вот, теперь Вы знаете за что отвечают эти типы переменных:

Что ещё Вы должны знать?

1. Вы должны знать, что эти типы переменных относятся к так называемым примитивным типам переменных. Поэтому если услышите "примитивные типы данных" , "примитивы" или "primitives", знайте, речь идёт о 8 типах переменных - byte, short, int, long, float, double, char, boolean.

2. Есть еще один тип переменных - тип String . О нём мы поговорим в статье "Как присвоить значение переменной"

3. В Java очень важно п равильно оформлять код . Да-да, не только писать работающие программы, но ещё и правильно оформленные. Существует целый свод правил, который называется Code Conventions в Java. Так что можете смело скачивать и постепенно изучать. А сейчас мы рассмотрим только часть Code Conventions, а именно правила написания названий переменных. Итак, запоминаем.

5 правил выбора названий для переменных:

Правило №1 - переменные пишутся только латинскими буквами. Никакой кириллицы!!!

Например:

Правило №2 – имя переменной, по возможности, должно быть "говорящим"

Например:

int s; // так можно называть переменную, но когда кода много и все переменные имеют не говорящие названия, код очень тяжело читать

int size; // этот вариант более "говорящий", чем первый вариант int s; поскольку понятно из названия, что переменная отвечает за размер чего-то

Правило №3 - с чего может/не может начинаться имя переменной

Может начинаться с:

1. Любых латинских букв
2. $ или _

Не может начинаться с:

Ниже приводим несколько примеров - правильных и неправильных.

Правильно:

• int square;
• int $money;
• int width;
• int boxSize;
• double sum;
• double sumJune;

Неправильно:

• int 2square;
• int 101dalmatians;

Правило №4 – название переменной, состоящее из 2 и более слов, пишется в CamelStyle

Что такое CamelStyle мы с Вами уже обсудили в этой статьей чуть выше.

Правило №5 – нельзя использовать в названиях переменных эти 54 слова:

abstract, assert, boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum, extends, false, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, null, package, private, protected, public, return, short, static, strictfp, String, super, switch, synchronized, this, throw, throws, transient, true, try, void, volatile, while

Эти 54 слова имеют особое значение при написании кода на Java . Постепенно Вы поймёте где используется каждое слово. Причём после прочтения этой статьи, из 54 слов Вам уже станут знакомы те слова, которые мы выделили синим:

abstract, assert, boolean , break, byte , case, catch, char , class, const, continue, default, do, double , else, enum, extends, false , final, finally, float , for, goto, if, implements, import, instanceof, int , interface, long , native, new, null, package, private, protected, public, return, short , static, strictfp, String , super, switch, synchronized, this, throw, throws, transient, true , try, void, volatile, while

ПОДЫТОЖИМ:

Всего 4 группы переменных:

1. Целочисленные (к ним относятся byte, short, int, long)
2. С плавающей точкой (к ним относятся float, double)
3. Символы (char)
4. Логические (boolean)

Эти 8 типов переменных (byte, short, int, long, float, double, char, boolean) относятся к там называемым примитивным типам переменных.

Прежде чем использовать переменную, её необходимо объявить:

5 правил выбора названий переменных:

1. Переменные пишутся только латинскими буквами. Никакой кириллицы!!!
2. Имя переменной, по возможности, должно быть "говорящим"
3. Если переменная состоит из 2 и более слов, пишется в CamelStyle (другое название - CamelCase)
4. Есть 54 слова, которые нельзя использовать в названиях переменных
5. Имя переменной:

• может начинаться с любых латинских букв, $ или _
• не может начинаться с цифр

Также есть еще один тип переменных - тип String, о котором мы поговорим в статье "Как присвоить значение переменной в Java"

Надеемся, что наша статья была Вам полезна. Также есть возможность записаться на наши курсы по Java в Киеве. Обучаем с нуля.

По всем вопросам звоните:

38 050 205 77 99

38 098 205 77 99

Или читайте информацию по нашим курсам Java c нуля у нас на .

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