Урок 2. Переменные и типы данных

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

Объявление переменной

Переменную объявляют так: тип, имя, знак = и начальное значение.

public class Main {
    public static void main(String[] args) {
        int age = 16;
        double height = 1.75;
        char grade = 'A';
        boolean isStudent = true;
        String name = "Анна";

        System.out.println(name);
        System.out.println(age);
        System.out.println(height);
        System.out.println(grade);
        System.out.println(isStudent);
    }
}

Анна
16
1.75
A
true

Значение можно поменять позже — уже без указания типа: age = 17;. Объявить переменную с тем же именем второй раз в том же методе нельзя.

Имена переменных пишут латиницей, в стиле camelCase: первое слово с маленькой буквы, следующие — с большой (studentName, totalPrice). Имя не может начинаться с цифры и совпадать со служебным словом (class, int).

Основные типы

Первые восемь типов называются примитивными: они хранят само значение. String — не примитивный тип, а класс; строкам посвящён отдельный урок.

Обратите внимание на запись чисел:

• дробная часть отделяется точкой: 1.75, а не 1,75;
• число больше int записывают с буквой L на конце: 3000000000L; без неё компилятор сообщит, что число слишком большое;
• у float в конце буква f: без неё 2.5 считается double;
• для читаемости в числе можно ставить подчёркивания: 1_000_000 — то же, что 1000000.

Для обычных целых чисел берите int, для больших — long, для дробных — double.

Арифметика

public class Main {
    public static void main(String[] args) {
        int a = 17;
        int b = 5;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);
        System.out.println(a % b);
        System.out.println((double) a / b);
    }
}

22
12
85
3
2
3.4

Главное, что здесь нужно запомнить:

• Деление целых даёт целое: 17 / 5 — это 3, дробная часть отбрасывается. Чтобы получить 3.4, хотя бы одно число должно быть дробным: (double) a / b или a / 5.0.
• % — остаток от деления: 17 % 5 = 2. Так проверяют чётность (n % 2 == 0) и делимость.
• Порядок действий как в математике: сначала *, /, %, потом + и -. Скобки меняют порядок.

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

public class Main {
    public static void main(String[] args) {
        int count = 10;
        count++;
        count += 5;
        count--;
        count *= 2;
        System.out.println(count);
    }
}

30

count++ прибавляет единицу (11), count += 5 — пять (16), count-- вычитает единицу (15), count *= 2 умножает на два (30).

Строки и числа вместе

Знак + со строкой не складывает, а склеивает. Выражение читается слева направо, и как только встретилась строка, дальше всё склеивается:

public class Main {
    public static void main(String[] args) {
        int x = 2;
        int y = 3;
        System.out.println("Сумма: " + x + y);
        System.out.println("Сумма: " + (x + y));
        System.out.println(x + y + " — сумма");
    }
}

Сумма: 23
Сумма: 5
5 — сумма

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

Приведение типов

Из «меньшего» типа в «больший» значение переходит само: double d = 7; даёт 7.0. Обратно — только явно, с указанием типа в скобках, потому что часть значения может потеряться:

public class Main {
    public static void main(String[] args) {
        double price = 9.99;
        int whole = (int) price;
        System.out.println(whole);
        char letter = 'A';
        System.out.println(letter + 1);
        System.out.println((char) (letter + 1));
    }
}

9
66
B

(int) отбрасывает дробную часть, а не округляет: из 9.99 получается 9. Символ — это число (его код), поэтому 'A' + 1 даёт 66, а приведение к char превращает код обратно в символ. Если написать int whole = price; без приведения, компилятор остановится с ошибкой incompatible types: possible lossy conversion from double to int.

Переполнение и неточность

У каждого типа свой предел. Если перейти его, значение «перескакивает» на другой конец диапазона — без всякой ошибки:

public class Main {
    public static void main(String[] args) {
        int big = 2147483647;
        big = big + 1;
        System.out.println(big);
        long ok = 2147483647L + 1;
        System.out.println(ok);
        System.out.println(0.1 + 0.2);
    }
}

-2147483648
2147483648
0.30000000000000004

Дробные числа хранятся в двоичном виде и не всегда точно: 0.1 + 0.2 чуть больше 0.3. Поэтому дробные числа не сравнивают через ==, а для денег используют целые копейки или класс BigDecimal.

Константы и var

Слово final запрещает менять переменную после первого значения — так объявляют константы. Их имена принято писать большими буквами:

final int DAYS_IN_WEEK = 7;

С Java 10 вместо типа локальной переменной можно написать var — компилятор выведет тип из значения: var count = 5; — это int, var name = "Анна"; — String. Тип всё равно есть и не меняется, var лишь сокращает запись.

Частые ошибки

• variable x might not have been initialized — переменной не дали значения перед использованием.
• cannot find symbol — опечатка в имени или переменная объявлена в другом месте программы.
• integer number too large — большое число записано без L.
• Дробь через запятую (1,5) — в Java это ошибка: дробная часть отделяется точкой.

Коротко

• У переменной есть тип: int, long, double, char, boolean, String и другие; тип не меняется.
• Деление целых отбрасывает дробную часть, % — остаток от деления.
• + со строкой склеивает, выражение читается слева направо.
• Из double в int — только явно: (int) x, дробная часть отбрасывается.
• int переполняется молча; для больших чисел — long, для точных денег — целые копейки или BigDecimal.

Проверьте себя