Как объявить переменную в java

Variables

As you learned in the previous lesson, an object stores its state in fields.

The What Is an Object? discussion introduced you to fields, but you probably have still a few questions, such as: What are the rules and conventions for naming a field? Besides int , what other data types are there? Do fields have to be initialized when they are declared? Are fields assigned a default value if they are not explicitly initialized? We'll explore the answers to such questions in this lesson, but before we do, there are a few technical distinctions you must first become aware of. In the Java programming language, the terms "field" and "variable" are both used; this is a common source of confusion among new developers, since both often seem to refer to the same thing.

The Java programming language defines the following kinds of variables:

• Instance Variables (Non-Static Fields) Technically speaking, objects store their individual states in "non-static fields", that is, fields declared without the static keyword. Non-static fields are also known as instance variables because their values are unique to each instance of a class (to each object, in other words); the currentSpeed of one bicycle is independent from the currentSpeed of another.
• Class Variables (Static Fields) A class variable is any field declared with the static modifier; this tells the compiler that there is exactly one copy of this variable in existence, regardless of how many times the class has been instantiated. A field defining the number of gears for a particular kind of bicycle could be marked as static since conceptually the same number of gears will apply to all instances. The code static int numGears = 6; would create such a static field. Additionally, the keyword final could be added to indicate that the number of gears will never change.
• Local Variables Similar to how an object stores its state in fields, a method will often store its temporary state in local variables. The syntax for declaring a local variable is similar to declaring a field (for example, int count = 0; ). There is no special keyword designating a variable as local; that determination comes entirely from the location in which the variable is declared — which is between the opening and closing braces of a method. As such, local variables are only visible to the methods in which they are declared; they are not accessible from the rest of the class.
• Parameters You've already seen examples of parameters, both in the Bicycle class and in the main method of the "Hello World!" application. Recall that the signature for the main method is public static void main(String[] args) . Here, the args variable is the parameter to this method. The important thing to remember is that parameters are always classified as "variables" not "fields". This applies to other parameter-accepting constructs as well (such as constructors and exception handlers) that you'll learn about later in the tutorial.

Having said that, the remainder of this tutorial uses the following general guidelines when discussing fields and variables. If we are talking about "fields in general" (excluding local variables and parameters), we may simply say "fields". If the discussion applies to "all of the above", we may simply say "variables". If the context calls for a distinction, we will use specific terms (static field, local variables, etc.) as appropriate. You may also occasionally see the term "member" used as well. A type's fields, methods, and nested types are collectively called its members.

Как объявить переменную в Java? Инициализация переменной в Java. Константы в Java

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

Переменная — это контейнер, содержащий какое-либо значение. При этом под переменным значением понимают строковое, числовое или логическое значение. Само определение говорит нам о том, что переменная может изменяться по ходу выполнения программы. А вот если у нас задана константа, то это значение меняться не может. Но давайте обо всём по порядку.

Виды переменных в Java

Существуют следующие типы переменных в Java: 1) примитивные (целые — byte, short, char, int, long; дробные или с плавающей точкой — float, double, логические — boolean); 2) ссылочные (создаются с применением конструкторов классов и нужны для доступа к объектам).

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

Как объявлять переменные в Java?

Перед использованием переменной нужно её объявить. Для объявления переменной в Java используют следующий синтаксис:

Идём дальше: если нужно объявить больше чем одну переменную указанного типа, допускается применение списка с запятыми:

Инициализация переменной

Перед использованием переменной, нужно задать ей начальное значение. Этот процесс называется инициализация. Без инициализации мы можем получить ошибку во время выполнения программы, поэтому инициализация очень важна. Для инициализации переменной используют оператор присваивания. Слева указывается имя переменной, справа её значение.

Вот пример инициализации:

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

Типы переменных в Java

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

Теперь давайте рассмотрим их подробнее.

Локальные переменные в Java

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

Пример локальных переменных

Итак, «age» — это наша переменная, определяемая внутри метода pupAge() , причём область её действия ограничивается лишь этим методом:

В итоге мы получим следующий результат:

Пример локальных переменных без инициализации

Мы уже говорили о том, что переменная без инициализации приведёт к ошибке компиляции и упоминали о важности такой процедуры, как инициализация. Давайте чуть-чуть изменим код и попробуем выполнить нашу программу без инициализации переменной «age»:

Запустив компиляцию без инициализации, мы увидим следующую ошибку:

Пожалуй, об инициализации уже поговорили достаточно. Идём дальше.

Переменные экземпляра

Для начала рассмотрим основные свойства переменных экземпляра: — объявляются в классе, однако за пределами метода, блока, конструктора; — когда в стеке выделяется пространство для объекта, создаётся слот для всех значений переменных экземпляра; — в Java эти переменные создаются тогда, когда объект создаётся посредством ключевого слова «new», а удаляются, когда объект уничтожается; — переменные включают значения, ссылающиеся более чем на один метод, блок или конструктор; — переменные экземпляра можно объявить на уровне класса, а также до и после использования; — для переменных экземпляра могут быть предоставлены модификаторы доступа; — эти переменные в Java видимы для всех методов, блоков и конструкторов в классе. Рекомендуется делать их private. Также можно делать их видимыми для подклассов данных переменных посредством модификаторов доступа; — переменные имеют значения по умолчанию: 0 — для чисел, false — для логических значений, null — для ссылок на объект. Значения можно присвоить в конструкторе либо при объявлении; — переменные могут быть доступны при вызове имени переменной внутри класса. При этом в статических методах и разных классах они вызываются посредством полного имени — ObjectReference.VariableName .

Результат работы нашей программы следующий:

Рассмотрение переменных класса (статических переменных в Java) выходит за рамки нашей статьи. Давайте лучше поговорим о том, что такое константа и зачем нужны константы в Java.

Для чего используются константы?

Константы применяются в Java для хранения данных. Константа отличается от переменной. Главное отличие в том, что при использовании константы мы можем присвоить значение лишь один раз.

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

Как правило, при записи имени константы применяют верхний регистр.

Константы позволяют задать переменные, которые больше не должны меняться. Допустим, у нас существует переменная для хранения числа «пи». При инициализации мы можем сразу же объявить, что она константа, ведь её значение постоянно.

На этом пока всё. Если хотите знать больше, чем объявление, инициализация и использование переменной, записывайтесь на курс «Разработчик Java». Здесь вы получите навыки разработки серверных приложений, овладеете низкоуровневыми и высокоуровневыми подходами к созданию многопоточных и многопроцессных приложений и много чего ещё.

Переменные в Java

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

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

Помните, как в школе было: 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. Целочисленные (к ним относятся byte, short, int, long)
2. С плавающей точкой (к ним относятся float, double)
3. Символы (char)
4. Логические (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 — «верблюд»).

Видите, названия примеров переменных состоят из 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. $ или _

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

1. Цифр

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

Правильно:

• 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 Core для самых маленьких. Часть 3. Переменные

В предыдущей статье мы говорили о типах данных, а теперь поговорим о вытекающей из этого теме, о переменных.

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

На скриншоте выше продемонстрирован пример создания переменных.

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

Имя или Идентификатор — любую переменную нужно как-то обозвать. А даем мы имя переменной сразу после указания типа данных. Важно! Именем переменной может быть любая последовательность букв, цифр, но имя не может начинаться с цифры! При наименовании переменной так же учитывается регистр символов. abc и ABC будут разными именами. Еще можно встретить переменные, имя которых начинается с символа валюты доллара: $
Например: double $pi = 3.14; Такое можно увидеть в авто-генерируемых участках кода. Живые люди, насколько мне известно, так не пишут.

Давайте сразу научимся давать имена переменным правильно. Существует документ Java Code Conventions. В нем указаны правила к написанию кода на Java. Нужно это для того, что бы Java код в разных проектах был написан в едином стиле. Таким образом, новоприбывший на проект программист не будет отвлекаться на новый стиль кода, ведь он будет оформлен так же, как и на других проектах. Эти правила работают и при нейминге переменных.

Итак, переменные принято называть в lowerCamelCase стиле. Сейчас покажу как хорошо, а как плохо:

Как вы могли заметить, в примере, в имени переменной используется символ подчеркивания _ . На практике допускается использовать такой символ только для имен констант. Чем константа отличается от переменной? Переменная на то и переменная, что ее значение изменчиво и всегда можно присвоить другое:

Вот было значение 1998, а на следующей строке стало 2000. А вот с константой так не получится. Константа гарантирует, что ее значение не изменится на протяжении всего времени выполнения программы. Как создать константу? Очень просто:

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

Обратим внимание на имя константы. Когда мы даем имя константе, то должны делать это в стиле SCREAMING_SNAKE_CASE. Давайте исправим мой код:

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

Инициализация переменных

У всех переменных из моих примеров уже было присвоено начальное значение. Процесс присвоения начального значения называется инициализацией переменной. И не обязательно инициализировать переменную во время ее объявления. Java позволяет сделать это и позже.

Во-первых, можно объявлять переменные через запятую (если они одинакового типа):

При этом, смотрите, мы можем некоторые из них инициализировать прямо во время объявления. А теперь инициализируем оставшиеся:

Для инициализации переменных типа char я использовал цепочку присваиваний. Да, и так тоже можно. Хотя используется очень редко.
Если мы попытаемся провести какую-то операция с переменной, у которой нет значения, то получим ошибку.

Оператор присваивания

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

Литералы

Видели, в моих примерах выше, я писал значение переменной с типом long не просто 1998 а 1998L ? Сейчас расскажу, что это за L в конце.

В Java постоянные значения задаются литеральным представлением. Простым языком, при помощи определенных символов мы можем указывать тип данных. Вот например, при работе с целочисленными литералами нам не нужны никакие литералы. Мы просто пишем число 1998; и Java понимает, что это целочисленное значение.

Целочисленные литералы по умолчанию создаются в виде значения типа int , и это значение можно присваивать всем целочисленным типам данных без проблем, в случае, если это значение не выходит за пределы допустимых значений (в предыдущей статье мы говорили о диапазонах значений у разных типов данных). Но что делать, если мы хотим указать целое число, которое больше пределов числа типа int ? В этом случае есть возможность создать литерал типа long просто указав в конце символ L . Я мог и не писать 1998L , потому что число 1998 вполне помещается в диапазон значений типа данных int . А теперь, я вдруг захотел присвоить переменной типа long значение, скажем, в девять миллиардов. Число не маленькое и оно выходит за пределы максимального значения типа int .

Вот тут нам понадобится литерал типа long . При помощи символа L , в конце целочисленного значения, мы явно указывается, что это значение будет типа long , а следовательно и с большим диапазоном значений.

Так, что еще за символы подчеркивания в значении переменной? Это всего-навсего декор. С JDK 7 допустимо указывать знаки подчеркивания, для разбиения больших чисел на разряды, для удобства чтения.

В вышеописанных примерах были литералы для целочисленных десятичных значений. А еще мы можем присвоить целому числу литерал в виде восьмеричного значения. Для этого вам нужно добавить в самом начале значения 0. Но в таком случае, логично, что это значение не сможет содержать цифры 8 и 9, поскольку они выходят за пределы восьмеричной системы счисления.

Мало того, еще мы можем использовать литерал шестнадцатеричных значений. Такие значения обозначают с начальным 0x или 0X, а цифры в пределах от 10 до 15 заменяются символами ABCDEF английского алфавита.

С JDK 7 есть возможность указывать целочисленные литералы в двоичном виде. Для этого вначале значения нужно указать 0b или 0B и соответственно в значениях можно использовать только цифры 0 и 1. В реальности, вам навряд ли понадобятся литералы шестнадцатеричных, восьмеричного или двоичных значений. Однако, знать о них нужно.

Литералы дробных чисел

Литералы дробных чисел могут быть представлены в привычном для нас виде. Они состоят из целой и дробной части, которые разделены точкой. Например: 10.9; .

Но существует и экспоненциальная форма записи этих чисел в виде 2.34e12;

Где число после символа ‘e’ обозначает степень 10-ти. Простыми словами, мы записали 2 целых и 34 сотых умноженное на 10 в 12 степени.

По умолчанию литералы дробных чисел имеют тип double , если хотим создать литерал типа float , нужно указать символ f или F в конце значения. Как я уже сказал, по умолчанию, литерал будет типа double , однако мы все же можем указать это явно, дописав в конце значения символ d или D . Особого смысла это иметь, конечно же, не будет.

Как и в случае с целочисленными значениями, литералы с плавающей точкой поддерживают нижнее подчеркивание начиная с JDK 7.

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

С логическими литералами все просто, они поддерживают только два логических значения true или false .

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

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

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

Как я уже говорил, тип char целочисленный и может хранить в себе символы кодировки Unicode. Unicode — это стандарт кодировки символов, который присваивает каждому символу код, в виде положительного целочисленного значения. Поэтому, тип char не может хранить отрицательные значения. А также, над типом char можно выполнять операции сложения и вычитания. Не представляю, зачем кому-то может понадобиться выполнять арифметические операции над типом char , но знайте, Java это позволяет. Мало того, коды символов английского алфавита (и многих других), расположены в порядке возрастания. Например, символу a соответсвует код 97, символу b — код 98. На основе этого можно сортировать символы по алфавиту.

А вот если символ нельзя ввести непосредственно с клавиатуры, то для ввода таких символов используют ряд управляющих последовательностей. Например, символ переноса строки ‘\n’. Существуют последовательности, которые существуют для ввода значений в восьмеричной и шестнадцатеричной форме. Например, мы захотели ввести букву tu катаканы смайлик: ツ. Берем и пишем:

В данной таблице вы можете посмотреть наиболее используемые последовательности символов:

Когда-то давно, я писал статью про экранирование символом. Настоятельно рекомендую прочитать, как дополнительный материал. Узнаете много интересного.

Строковый литерал

Можно заключить последовательность символов в двойные кавычки и получить так называемую строку.

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

Динамическая инициализация

Пару слов о таком термине как динамическая инициализация. Ничего сложного, только звучит страшно.

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

Главное, чтобы тип данных выражения / инициализирующей переменной совпадал с типом данных целевой переменной.

Преобразование и приведение типов

Знаю, вы уже подустали, сделали массу перерывов и подходов. Обещаю, это последняя тема в этой статье.

Часто программисты сталкиваются с ситуацией, когда переменной одного типа приходится присваивать значение другого типа. Если оба типа данных совместимы, их преобразование будет выполнено автоматически. Для автоматического преобразования должно выполняться 2 условия:

Не так страшен черт, как его малюют. Все очень просто. Например, тип long достаточно велик чтобы поместить в себя тип int и прочие целочисленные типы данных которые меньше long .

На картинке выше, вы можете увидеть, какие типы данных вы можете преобразовать автоматически. Исходя из этого изображения, мы можем в переменную типа float поместить значение типа long . Звучит странно, давайте проверим:

Все работает. К сожалению, автоматическое преобразование не способно покрыть все потребности. Например если нужно тип int преобразовать в byte .

Чтобы выполнить преобразование двух несовместимых типов данных, нужно воспользоваться приведением типов. Это явное преобразование одного типа в другой. И выглядит это вот так:

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

Подводим итоги

В этой статье мы поговорили о многих важных вещах. Узнали, как создавать переменные и константы в Java, и чем они отличаются. Узнали о способах инициализации переменных. Разобрались с тем, что такое литералы и какие они бывают. А так же выполнили преобразование и приведение типов данных.

Скажем спасибо Егору за предоставленный материал.

В следующей статье мы будем изучать массивы. Если переменная — это вагон, то поездом будет массив. В общем, будет опять многобукав и многомерные массивы. Всем спасибо за внимание. Учитесь старательно!