Переменные и константы

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

📦 Что такое переменная

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

Переменная — это именованный контейнер для хранения данных. Каждая переменная имеет три характеристики:

• Имя — по которому мы обращаемся к переменной (например, age)
• Тип — какого рода данные хранятся (число, текст, логическое значение)
• Значение — то, что реально лежит внутри (например, 25)

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

int age = 25;
String name = "Анна";
boolean isStudent = true;

Здесь:

• int — тип (целое число)
• age — имя переменной
• = — оператор присваивания (не «равно» в математическом смысле!)
• 25 — значение
• ; — завершение инструкции

📝 Объявление и инициализация переменных

В Java есть два шага при работе с переменной:

1. Объявление — создать переменную (сказать Java, что она существует)
2. Инициализация — присвоить первое значение

int age;           // объявление: создали пустую коробку
age = 25;          // инициализация: положили значение 25

int score = 100;   // объявление + инициализация в одной строке

Попытка использовать переменную до инициализации вызовет ошибку:

int x;
System.out.println(x);  // ошибка: variable x might not have been initialized

Java защищает вас от работы с пустыми переменными — это одна из причин, почему Java считается безопасным языком.

Можно объявить несколько переменных одного типа в одной строке:

int x = 10, y = 20, z = 30;

Однако так делать не рекомендуется — лучше объявлять каждую переменную отдельно для читаемости кода.

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

Java提供ляет 8 примитивных типов — это базовые строительные блоки для данных. Подробно мы разберём каждый из них в Module 2, а пока — обзор:

int age = 25;
double price = 19.99;
char grade = 'A';
boolean isActive = true;
long population = 8_000_000_000L;

Обратите внимание на 8_000_000_000L — подчёркивания игнорируются Java и служат только для читаемости. А суффикс L говорит Java, что это тип long, а не int.

📝 Строки — ссылочный тип

Строки в Java — это не примитивный тип, а объект. Это значит, что строка — это не просто набор символов, а полноценный объект со своими методами:

String name = "Анна";
String greeting = "Привет, " + name + "!";
int length = greeting.length();   // 18
boolean hasA = greeting.contains("Анна");  // true

Обратите внимание: тип строки пишется как String (с большой буквы S), потому что это класс, а не примитив. Примитивные типы в Java пишутся строчными буквами (int, double, boolean).

Строки заключаются в двойные кавычки. Одинарные кавычки — для символов типа char:

String text = "Привет";   // строка — двойные кавычки
char symbol = 'A';          // символ — одинарные кавычки

🏷️ Правила именования переменных

Java имеет строгие правила именования. Нарушение правил вызовет ошибку компиляции:

int age;
int myAge;
int _age;
int $age;
int age2;
int MAX_SIZE;

int 2age;        // нельзя начинать с цифры
int my-age;      // нельзя использовать дефис
int my age;      // нельзя использовать пробел
int class;       // нельзя использовать ключевые слова

Но правила и именование — это разные вещи. Правила — это минимум, а именование — это стиль. Вот рекомендации:

• camelCase — начинайте со строчной буквы, далее заглавные: firstName, age, totalScore
• Осмысленные имена: age лучше, чем a, studentCount лучше, чем sc
• Не используйте сокращения: count, а не cnt
• Булевы переменные: начинайте с is, has, can: isActive, hasPermission

int studentCount = 30;
String firstName = "Анна";
boolean isActive = true;
double totalScore = 95.5;

🔒 Константы: final

Иногда значение переменной не должно меняться. Например, число Пи = 3.14159... всегда одно и то же. Для этого в Java используется ключевое слово final:

final double PI = 3.14159;
final int MAX_USERS = 100;
final String COUNTRY = "Россия";

MAX_USERS = 200;  // ошибка! нельзя изменить final переменную

Попытка изменить final-переменную вызовет ошибку компиляции. Java не позволяет этого.

По convention, имена констант пишутся ЗАГЛАВНЫМИ БУКВАМИ с подчёркиваниями:

final int MAX_SIZE = 100;       // константа
final double TAX_RATE = 0.13;   // константа
final String APP_NAME = "MyApp"; // константа

Константы полезны, потому что:

• Запрещают случайное изменение важных значений
• Дают осмысленные имена вместо «магических чисел»
• Делают код читаемым и поддерживаемым

🔮 Локальная инференция: var (Java 10+)

Начиная с Java 10, можно не указывать тип явно — Java сама определит его из значения:

var age = 25;           // Java понимает, что это int
var name = "Анна";      // Java понимает, что это String
var price = 19.99;      // Java понимает, что это double
var isActive = true;    // Java понимает, что это boolean

Это называется локальная инференция типов. Java смотрит на правую часть выражения и сама определяет тип переменной. Результат точно такой же, как если бы вы написали тип явно.

Когда var удобен:

var numbers = new ArrayList<Integer>();  // без var было бы многословно
var connection = DriverManager.getConnection(url);
var result = processLargeDataset(data);

Когда var — плохая идея:

var x = 10;         // неочевидно — int или double?
var temp = getData(); // что возвращает getData?

Важные ограничения var:

• Только для локальных переменных (внутри методов), не для полей класса
• Обязательна инициализация: var x; — ошибка
• Нельзя использовать для параметров методов и возвращаемых значений (пока)

🎯 Практика: простая программа

Давайте напишем программу, которая использует переменные для вывода информации:

public class AboutMe {
    public static void main(String[] args) {
        String name = "Анна";
        int age = 22;
        double height = 1.68;
        boolean isStudent = true;
        String city = "Москва";

        System.out.println("Имя: " + name);
        System.out.println("Возраст: " + age);
        System.out.println("Рост: " + height + " м");
        System.out.println("Студент: " + isStudent);
        System.out.println("Город: " + city);
    }
}

Вывод:

Имя: Анна
Возраст: 22
Рост: 1.68 м
Студент: true
Город: Москва

Заметьте, как удобно: создали переменные один раз, а используете сколько угодно. И если нужно изменить данные — меняем значение в одном месте, а не везде по коду.

✅ Итоги урока

• Переменная — именованный контейнер для данных с типом и значением
• Объявление: тип имя = значение;
• 8 примитивных типов: byte, short, int, long, float, double, char, boolean
• String — ссылочный тип (объект), не примитив
• Именование: camelCase, осмысленные имена, без ключевых слов
• final — создаёт константу, которую нельзя изменить
• var (Java 10+) — позволяет не указывать тип явно, если он очевиден

Отлично! Теперь вы знаете, как работают переменные. Следующий урок: Комментарии и стиль кода →