Зарегистрируйтесь для доступа к 15+ бесплатным курсам по программированию с тренажером

Переменные — Основы Java

Представьте себе задачу — нужно напечатать на экран фразу Father! два раза. Эту задачу можно решить в лоб:

System.out.println("Father!"); // => Father!
System.out.println("Father!"); // => Father!

В простейшем случае так и стоит поступить, но если фраза Father! начнет использоваться чаще, да еще и в разных частях программы, то придется ее везде повторять. Проблемы с таким подходом начнутся тогда, когда понадобится изменить нашу фразу, а такое происходит довольно часто. Нам придется найти все места, где использовалась фраза Father! и выполнить необходимую замену. А можно поступить по-другому. Вместо копирования нашего выражения, достаточно создать переменную с этой фразой:

// greeting – переводится как приветствие
// var – нужен только при определении переменной
var greeting = "Father!";
System.out.println(greeting);
System.out.println(greeting);

Код выше состоит из таких компонентов:

Определение переменной

В строчке var greeting = "Father!" происходит присваивание значения "Father!" переменной с именем greeting.

Когда переменная создана, можно начать ее использовать. Она подставляется в те места, где раньше стояла наша фраза. Во время выполнения кода в строке System.out.println(greeting) вместо переменной подставляется ее содержимое, а затем выполняется код. В результате вывод нашей программы будет таким:

Father!
Father!

Для имени переменной используется любой набор допустимых символов, к которым относятся буквы английского алфавита, цифры, знаки - и _. При этом цифру нельзя ставить в начале. Имена переменных регистрозависимы, то есть имя hello и имя heLLo - это два разных имени и две переменные. Ниже пример с двумя разными переменными:

var greeting1 = "Father!";
System.out.println(greeting1);
System.out.println(greeting1);
var greeting2 = "Mother!";
System.out.println(greeting2);
System.out.println(greeting2);

Father!
Father!
Mother!
Mother!

https://replit.com/@hexlet/java-basics-variables-1

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

Изменение переменной

Само слово «переменная» говорит, что ее можно менять, так как с течением времени внутри программы значения переменных могут изменяться:

var greeting = "Father!";
System.out.println(greeting);
System.out.println(greeting);
// var уже не используется, так как переменная была определена выше
greeting = "Mother!";
System.out.println(greeting);
System.out.println(greeting);

https://replit.com/@hexlet/java-basics-variables-2

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

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

greeting = 5;
# Error:
# incompatible types: int cannot be converted to java.lang.String
# несовместимые типы: число не может быть превращено в строку

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

Ошибки при работе с переменными

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

System.out.println(greeting);
var greeting = "Father!";

Запуск программы выше завершается с ошибкой:

Error: java: cannot find symbol
symbol: variable greeting

Ошибка cannot find symbol означает, что в коде используется переменная, которая не определена. Причем в самой ошибке об этом говорят прямо: variable greeting.

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

Еще одна распространенная ошибка — попытаться объявить уже объявленную переменную:

var greeting = "Father!";
var greeting = "Father!";

Так делать нельзя. Придется создать новую переменную.

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

Выражения в определениях

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

Давайте рассмотрим пример: нужно перевести евро в рубли через доллары. Подобные конвертации через промежуточную валюту часто делают банки при покупках за рубежом.

Для начала переведем 50 евро в доллары. Допустим, что один евро — 1.25 доллара:

var dollarsCount = 50 * 1.25;
System.out.println(dollarsCount);

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

var dollarsCount = 50 * 1.25;

Программа вычислит результат 62.5 и запишет его в переменную. С точки зрения программы не важно, что написано: 62.5 или 50 * 1.25. Оба варианта — выражения, которые надо вычислить. И они вычисляются в одно и то же значение 62.5.

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

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

62.5            // 62.5
50 * 1.25       // 62.5
120 / 10 * 2    // 24
"Hexlet"         // "Hexlet"
"Good" + "will" // "Goodwill"

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

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

Вернемся к нашей валютной программе. Запишем стоимость доллара в рублях, как отдельную переменную. Вычислим цену 50 евро в долларах, умножив их на 1.25. Допустим, что 1 доллар — 60 рублей:

var rublesPerDollar = 60;
var dollarsCount = 50 * 1.25; // 62.5
var rublesCount = dollarsCount * rublesPerDollar; // 3750
System.out.println(rublesCount); // => 3750

А теперь давайте добавим к выводу текст с помощью конкатенации:

var rublesPerDollar = 60;
var dollarsCount = 50 * 1.25; // 62.5
var rublesCount = dollarsCount * rublesPerDollar; // 3750
System.out.println("The price is " + rublesCount + " rubles");
// => The price is 3750 rubles

https://replit.com/@hexlet/java-basics-variables-3

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

Переменные и конкатенация

Переменные и конкатенацию можно объединять. Синтаксически ничего не меняется, ведь мы умеем конкатенировать — то есть склеивать две строки:

var what = "Kings" + "road";
System.out.println(what); // => Kingsroad

Значит, мы сумеем конкатенировать строку и одну переменную, в которой записана строка:

var first = "Kings";
var what = first + "road";
System.out.println(what); // => Kingsroad

Можно даже конкатенировать две переменные, в которых записаны строки:

var first = "Kings";
var last = "road";
var what = first + last;
System.out.println(what); //=> Kingsroad

https://replit.com/@hexlet/java-basics-variables-4

Константы

Некоторые данные никогда не меняются — например, математические постоянные. Возьмем число π. Приближенно оно всегда равно 3.14 и не может измениться.

Для обращения к подобным данным в Java принято использовать константы:

final var PI = 3.14;
System.out.println(PI); // 3.14

https://replit.com/@hexlet/java-basics-variables-5

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

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