До сих пор при определении переменных мы использовали ключевое слово var. Это может удивить тех, у кого уже есть опыт на Java. Обычно определение переменных показывают так:

int x = 3;
String greeting = "Hello Hexlet!";

Пришло время раскрыть карты. Java — это статически типизированный язык. В таких языках тип переменной фиксируется при ее объявлении и не меняется до конца работы программы. Перед именем переменной указывается ее тип. В примере выше это целое число (int) и строка (String).

Тип указывается явно и не меняется

В статически типизированном языке у каждой переменной есть тип, и он закреплен. Если переменная объявлена как int, то в нее можно положить только целое число:

int n = 5;
double x = 1.5;
boolean flag = true;
char c = 'A';
String s = "hi";

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

// Error: incompatible types: java.lang.String cannot be converted to int
int ops = "test";

Когда проверяются типы

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

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

У явного указания типов есть и второй плюс. Тип рядом с именем переменной работает как подсказка для того, кто читает код. По строчке int count = 0; сразу видно, что в переменной хранится целое число. Java берет на себя контроль типов, а код становится понятнее для людей.

Когда Java приводит типы сама

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

double result = 1 + 1.5;
System.out.println(result); // => 2.5

Целое 1 превращается в 1.0, и результат получается 2.5. Так происходит потому, что любое целое число точно представимо как рациональное, и данные не теряются. А вот строку и число Java сама смешивать не станет. Для этого нужно явное преобразование, и мы научимся его делать.

Вывод типов и слово var

Раньше на Java создавали переменные только с явным указанием типа, пока не появилось слово var. Это специальное ключевое слово, которое включает механизм вывода типов. Вывод типов сам определяет тип присваиваемого значения и связывает его с переменной:

// Компилятор понимает, что тут целое число
var age = 33;

// А тут строка
var name = "Tom";

Вывод типов появился в Java в 2018 году, хотя в некоторых других языках он существует не один десяток лет. Первый язык с выводом типов называется ML, и появился он аж в 1973 году. С тех пор вывод типов добавили в OCaml, Haskell, C#, F#, Kotlin, Scala и множество других языков.

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

Создайте строку One more time с явным указанием типа и выведите ее на экран