Переменные и типы данных в Java

Для того, чтобы тебе было проще понять, что такое переменная, вернемся к школьному курсу и вспомним простую формулу:

х+1 = y

Если мы подставим значение к «х», например, х = 1, то значение выражения будет равно «2». Соответственно, если х = 2, значение выражения будет «3» и так далее. Как видишь, все достаточно просто. «Х» в нашем случае переменная, куда мы помещаем любое значение. Подставляя его в формулу, мы получаем определенный результат.

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

В этом языке программирования выделяют четыре типа переменных:

1. Целочисленные. К этому типу относятся такие переменные, как byte, short, int, long.
   
   
2. С плавающей точкой. Сюда относятся float и double.
   
   
3. Символы.
   
   
4. Логические.
   
   

Как видно, всего переменных 8, однако есть еще и девятый тип переменных – void. Но этот тип мы не будем рассматривать в данной статье. Познакомимся поближе с каждым из типов переменных.

Уже из названия понятно, что в качестве значения таким переменным присваиваются целые числа. Например, это может быть 5, 10, 25, 100 и так далее. Причем они могут быть как положительными, так и отрицательными, в зависимости от потребности разработчика. А теперь рассмотрим подробнее каждый из видов переменных:

1. Byte – принимает значение от -128 до 127. Размер этой переменной – 1 байт памяти, что вполне логично исходя из названия.
   
   
2. Short – может принимать значения от -32768 до 32767. Размер такой переменной 2 байта.
   
   
3. Int – эта целочисленная переменная может принимать значения от -2147483648 до 2147483647. Ее размер составляет 4 байта.
   
   
4. Long – это самая большая с точки зрения размера переменная (8 байтов памяти). Она может принимать значения от -9223372036854775808 до 9223372036854775807.
   
   

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

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

Дальше, представим, что Вася, Катя и Аня выросли и стали заниматься поставками апельсинов. Теперь у каждого больше 1000 единиц этого вкусного фрукта. Объявлять byte мы больше не сможем. Если количество апельсинов не превышает 32767, мы можем работать с short, если больше с int и так далее.

Несмотря на то, что в Java представлено 4 целочисленных переменных, чаще всего будет использоваться только int. Более того этот тип в языке считается по умолчанию. А теперь посмотрим, как в Java объявляются переменные.

Приведем несколько примеров:

int oranges;

byte oranges;

long oranges;

В языке Java, как и в любом другом переменные лучше называть выразительно. То есть так, чтобы можно было понять, что именно в ней лежит. Например, если мы просто назовем три переменные byte oranges, не будет понятно, что это за апельсины.

Если речь идет об апельсинах Васи, такую переменную можно было бы назвать int vasyaOranges (или orangesVasya). Заметили одну интересную особенность? Слово vasya мы почему-то написали с маленькой, а Oranges с большой. Такой прием называется CamelCase. Он применяется тогда, когда название переменной или функции состоит из двух и более слов. Применяется исключительно для удобства. Читать переменную vasyaOranges куда удобнее, чем vasyaoranges. А если в названии переменной еще больше слов, то без CamelCase придется туго.

Вернемся к тем же действующим лицам. Итак, Вася, Катя и Аня снова держат апельсины. Только на этот раз, Васе досталось 3,5, Кате 2,5, а Ане 1,5 апельсина. Цель задачи остается той же – посчитать общее количество фруктов на руках у ребят.

В этом случае мы не можем использовать целочисленные переменные, так как речь идет о дробных числах. То есть мы не можем применять byte, short, int или long. Для этого существуют float и double. При этом:

1. Float принимает значения от -3.4Е + 38 до 3.4Е + 38. Размер такой переменной 4 байта.
   
   
2. Double принимает значения от -1.7Е+308 до 1.7Е + 308. Размер переменной 8 байт.
   
   

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

float oranges

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

float vasyaOranges (или orangesVasya)

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

С объявлением переменной типа char все также просто, как и с предыдущими:

char a;

char b;

В первом случае мы объявили символьную переменную а, а во втором – b.

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

var x = 10;

System.outprintln(x);

В этом примере мы задали переменную «х», которой присвоили значение 10. Соответственно, на экран будет выведено 10.

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

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

var x = 5 // это правильный вариант инициализации переменной

А вот в таком примере переменная создается неправильно:

var y;

y = 15;

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

final int NUMBER = 10;

System.out.println (NUMBER); // результате выполнения такого кода на экран будет выведено 10

NUMBER = 100; // а это уже неправильно, так как мы задали для константы значение 10.

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

Иногда ты встретишь также такое название, как булевые от английского Boolean. Значение булевых может быть только true и false. В чем их суть? Они позволяют определять является ли то или иное действие истиной или ложью. В зависимости от этого будет срабатывать какое-то событие.

Булевые значения применяются в ветвлениях. То есть серии, состоящей из «если … то тогда». Вот простейший пример того, где можно было бы применить булевые на практике:

У Васи есть апельсины. Если у него два апельсина, один он отдает Ане, а если у него один апельсин, он ничего не отдает Ане. Просто? Еще бы. Но в коде приложений чаще всего таких ветвлений очень много и условий тоже. Как объявляются булевые переменные?

По тому же принципу, что и остальные:

boolean a;

boolean b;

Помимо приведенных в статье типов переменных есть и еще один – String или строка. Эта переменная не относится к примитивным типам данных в отличие от всех, рассмотренных выше. Предназначена как уже можно догадаться из названия для хранения текста. Рассмотрим простой пример:

String a = "I have ";

String b = " oranges ";

var num = 3;

String c = a + num + b;

System.out.println(c); // в результате на экран будет выведена строка "I have 3 oranges"

В языке Java, как и в других используется только латиница. Соответственно, все названия переменных должны быть написаны исключительно на латинице. Употреблять кириллицу нельзя! К примеру

int abc; // правильно

int абв; // неправильно

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

var orangesVasya = 3;

var orangesKatya = 2;

var orangesAnya = 2;

Конечно, не будет неправильным и такой вариант:

var a = 3;

var b = 2;

var c = 2;

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

Еще при объявлении переменных очень важно учитывать, с чего может и не может начинаться ее название. Мы уже говорили про латиницу выше. Помимо букв, переменная может также начинаться с $ или _. А вот с цифр начинать имя переменной нельзя.

Рассмотрим несколько примеров того, как можно и как нельзя именовать переменные:

Можно:

int oranges;

int $oranges;

int orangesVasya;

int _oranges;

Нельзя:

int 2oranges;

int 202vasyaOranges;

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

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