Область видимости (scope)

Локальные переменные, поля класса, блочная область, shadowing и лучшие практики

Зачем изучать область видимости?

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

В программировании的概念 область видимости работает точно так же. Переменная — это как information, которая доступна в определённом месте вашего кода. В одних местах программа «видит» переменную, в других — нет. Понимание этих правил критически важно, потому что именно непонимание области видимости приводит к большинству ошибок у начинающих программистов.

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

Аналогия для запоминания: Область видимости — это как ваш дом. В вашей комнате (методе) вы знаете, где лежат ваши вещи (переменные). В соседней комнате (другом методе) этих вещей нет. А во дворе (классе) лежат вещи, доступные всем жильцам (поля класса). Если выйдете на улицу (вне класса), то увидите совсем другие объекты.

Что такое область видимости (scope)?

Область видимости (scope) — это участок программы, в пределах которого имя переменной доступно для использования. Проще говоря, это «территория», на которой ваша переменная «живёт» и может быть «увидена» кодом.

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

Давайте разберём это на наглядном примере. Посмотрите на код ниже — здесь переменная число объявлена внутри метода main и доступна только внутри фигурных скобок этого метода:

Как видите, переменная число не доступна в другом методе. Это и есть принцип области видимости — переменная «видна» только там, где она объявлена.

Типы переменных по области видимости

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

Давайте рассмотрим каждый тип подробно, начиная с самого распространённого — локальных переменных.

Локальные переменные: подробный разбор

Локальные переменные — это переменные, которые объявляются внутри метода, конструктора или блока кода. Они доступны только внутри той конструкции, в которой были объявлены.

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

Локальная переменная объявляется с указанием типа и имени. Она может быть инициализирована сразу или позже, но перед использованием обязательно должна быть инициализирована.

public class ЛокальныеПеременные {
    public static void main(String[] args) {
        int возраст;  // объявлена, но не инициализирована
        String имя = "Анна";  // объявлена и инициализирована
        double зарплата = 75000.50;  // объявляем с начальным значением

        возраст = 25;  // теперь инициализирована
        System.out.println(имя + ", " + возраст + " лет");

        // System.out.println(высота);  // ОШИБКА! переменная 'высота' не объявлена
    }
}

Правила работы с локальными переменными

Существует несколько важных правил, которые нужно запомнить:

int x = 10;
System.out.println(x);  // OK

int y = 20;
System.out.println(z);  // ОШИБКА! переменная z ещё не объявлена
int z = 30;

public class Пример {
    int x = 10;  // Это уже поле класса, не локальная переменная!

    public static void main(String[] args) {
        int y = 20;  // А вот это — локальная переменная
    }
}

public static void main(String[] args) {
    int x = 10;
    int x = 20;  // ОШИБКА! переменная x уже объявлена в этом методе
}

public static void main(String[] args) {
    int количество;
    System.out.println(количество);  // ОШИБКА! переменная не инициализирована
}

Время жизни локальной переменной

Время жизни (lifetime) — это период, в течение которого переменная существует в памяти. Для локальных переменных время жизни определяется非常简单: от момента объявления до момента завершения работы метода.

Представьте метод как поездку в лифте. Когда вы входите в лифт (метод начинает работать), вы объявляете переменные — кладёте вещи в лифт. Когда лифт едет, вы пользуетесь этими вещами. Когда вы выходите из лифта (метод завершается), все вещи остаются в лифте и исчезают — память освобождается.

public static void main(String[] args) {
    int a = 1;
    {
        int b = 2;
        System.out.println(a);  // OK — переменная a доступна
        System.out.println(b);  // OK — переменная b доступна
    }
    System.out.println(a);  // OK — переменная a всё ещё доступна
    // System.out.println(b);  // ОШИБКА! переменная b уже не существует
}

Практический пример: вычисление площади

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

public class ПлощадьТреугольника {
    public static void main(String[] args) {
        double основание = 10.5;
        double высота = 7.3;

        double площадь = 0.5 * основание * высота;

        System.out.println("Основание: " + основание);
        System.out.println("Высота: " + высота);
        System.out.println("Площадь: " + площадь);
    }
}

Все три переменные — основание, высота, площадь — локальные переменные метода main. Они доступны от строки объявления до закрывающей скобки метода.

Поля класса (instance и static переменные)

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

Instance-переменные (переменные экземпляра)

Instance-переменные создаются для каждого объекта класса отдельно. У каждого студента свой возраст, своё имя, своя оценка — это и есть instance-переменные.

public class Студент {
    String имя;        // поле класса (instance variable)
    int возраст;      // поле класса
    double среднийБалл; // поле класса

    public static void main(String[] args) {
        Студент студент1 = new Студент();
        студент1.имя = "Алексей";
        студент1.возраст = 20;
        студент1.среднийБалл = 4.5;

        Студент студент2 = new Студент();
        студент2.имя = "Мария";
        студент2.возраст = 19;
        студент2.среднийБалл = 4.8;

        System.out.println(студент1.имя + ": " + студент1.среднийБалл);
        System.out.println(студент2.имя + ": " + студент2.среднийБалл);
    }
}

Static-переменные (переменные класса)

Static-переменные принадлежат всему классу, а не отдельным объектам. Их значение общее для всех экземпляров. Хороший пример — счётчик студентов: он должен быть один на всех, а не у каждого студента свой.

public class СчётчикСтудентов {
    static int количество = 0;  // static поле — общее для всех
    String имя;

    public СчётчикСтудентов(String имя) {
        this.имя = имя;
        количество++;  // увеличиваем общий счётчик
    }

    public static void main(String[] args) {
        СчётчикСтудентов с1 = new СчётчикСтудентов("Аня");
        СчётчикСтудентов с2 = new СчётчикСтудентов("Борис");
        СчётчикСтудентов с3 = new СчётчикСтудентов("Вика");

        System.out.println("Всего студентов: " + количество);  // 3
    }
}

Сравнение: локальные переменные vs поля класса

Давайте наглядно сравним два типа переменных:

public class Сравнение {
    int поле = 100;  // поле класса — доступно везде в классе

    public static void main(String[] args) {
        Сравнение об = new Сравнение();
        System.out.println(об.поле);  // OK — поле доступно через объект

        int локальная = 200;  // локальная переменная
        System.out.println(локальная);  // OK
    }

    public static void другойМетод() {
        System.out.println(поле);  // OK — поле доступно
        // System.out.println(локальная);  // ОШИБКА! локальная переменная не видна
    }
}

Блочная область видимости

В Java область видимости определяется фигурными скобками { }. Каждый блок кода, ограниченный этими скобками, создаёт свою область видимости.

Область видимости в if-блоках

public static void main(String[] args) {
    int возраст = 25;

    if (возраст >= 18) {
        String статус = "совершеннолетний";  // объявлена в блоке if
        System.out.println("Статус: " + статус);
        System.out.println("Возраст: " + возраст);  // OK — возраст доступна
    }

    System.out.println(возраст);  // OK — возраст доступна
    // System.out.println(статус);  // ОШИБКА! статус не видна за пределами блока if
}

Обратите внимание: переменная возраст объявлена до блока if и доступна внутри него. А переменная статус объявлена внутри блока if и доступна только там.

Область видимости в циклах for

public static void main(String[] args) {
    for (int i = 0; i < 5; i++) {
        System.out.println("Число: " + i);
    }

    // System.out.println(i);  // ОШИБКА! переменная i не видна за пределами цикла

    for (int i = 0; i < 3; i++) {
        int квадрат = i * i;
        System.out.println(i + " в квадрате: " + квадрат);
    }

    // System.out.println(квадрат);  // ОШИБКА! квадрат не видна за пределами второго цикла
}

Важный момент: переменная i в первом цикле и переменная i во втором цикле — это РАЗНЫЕ переменные. Каждый цикл создаёт свою область видимости, и после завершения цикла переменная уничтожается.

Область видимости в цикле while

public static void main(String[] args) {
    int счётчик = 0;

    while (счётчик < 3) {
        System.out.println("Счётчик: " + счётчик);
        счётчик++;
    }

    System.out.println("Цикл завершён. Счётчик: " + счётчик);
}

В данном случае переменная счётчик объявлена до цикла, поэтому она доступна и после него. Это хороший паттерн, когда вам нужно значение переменной после завершения цикла.

Вложенные блоки и их область видимости

Блоки кода могут быть вложенными друг в друга. Внутренний блок «видит» переменные внешнего блока, но не наоборот:

public static void main(String[] args) {
    int a = 1;

    {  // внешний блок
        int b = 2;

        {  // внутренний блок
            int c = 3;
            System.out.println(a);  // OK — a видна
            System.out.println(b);  // OK — b видна
            System.out.println(c);  // OK — c видна
        }

        System.out.println(a);  // OK — a видна
        System.out.println(b);  // OK — b видна
        // System.out.println(c);  // ОШИБКА! c не видна во внешнем блоке
    }

    System.out.println(a);  // OK — a видна
    // System.out.println(b);  // ОШИБКА! b не видна после внешнего блока
    // System.out.println(c);  // ОШИБКА! c не видна
}

Практический пример: поиск максимального числа

public static void main(String[] args) {
    int[] числа = {3, 7, 2, 9, 4};
    int максимум = числа[0];  // предполагаем, что первый элемент — максимум

    for (int i = 1; i < числа.length; i++) {
        if (числа[i] > максимум) {
            максимум = числа[i];  // обновляем максимум
        }
    }

    System.out.println("Максимальное число: " + максимум);
}

Здесь переменные числа и максимум объявлены до цикла, поэтому доступны после него. А переменная i доступна только внутри цикла.

Shadowing (затенение переменных)

Shadowing — это ситуация, когда локальная переменная имеет то же имя, что и поле класса. В этом случае локальная переменная «затеняет» поле класса, и внутри метода под этим именем будет доступна только локальная переменная.

Пример shadowing

public class ПримерShadowing {
    int x = 10;  // поле класса

    public void метод() {
        int x = 20;  // локальная переменная — ЗАТЕНЯЕТ поле класса

        System.out.println(x);  // Выведет 20 (локальная переменная)
        System.out.println(this.x);  // Выведет 10 (поле класса через this)
    }

    public static void main(String[] args) {
        ПримерShadowing об = new ПримерShadowing();
        об.метод();
    }
}

Как видите, без ключевого слова this обращение к x возвращает значение локальной переменной (20). С помощью this.x мы обращаемся к полю класса (10).

Когда shadowing полезен?

Наиболее распространённый и полезный случай shadowing — в конструкторах и сеттерах, когда параметры имеют те же имена, что и поля:

public class Пользователь {
    String имя;
    int возраст;

    // Без shadowing — пришлось бы придумывать другие имена
    public Пользователь(String новоеИмя, int новыйВозраст) {
        имя = новоеИмя;
        возраст = новыйВозраст;
    }
}

// С shadowing — код чище и понятнее
public class Пользователь {
    String имя;
    int возраст;

    public Пользователь(String имя, int возраст) {
        this.имя = имя;      // this.имя — поле класса
        this.возраст = возраст;  // this.возраст — поле класса
    }
}

Опасности shadowing

Хотя shadowing бывает полезным, он может приводить к трудноуловимым ошибкам, особенно для начинающих:

public class ОпасныйПример {
    int количество = 100;

    public void добавить(int количество) {
        // ОШИБКА! Здесь 'количество' — это параметр метода (0), а не поле класса (100)
        количество = количество + 1;
        System.out.println("Результат: " + количество);  // Выведет 1, а не 101!
    }

    public static void main(String[] args) {
        ОпасныйПример об = new ОпасныйПример();
        об.добавить(0);  // Выведет "Результат: 1", а ожидалось 101
    }
}

В этом примере разработчик хотел увеличить поле количество класса, но из-за shadowing операция выполнилась над параметром. Чтобы исправить, нужно использовать this.количество.

Параметры метода как локальные переменные

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

Примеры с параметрами

public class ПримерыПараметров {

    public static void приветствовать(String имя) {
        // 'имя' — это локальная переменная, доступная только в этом методе
        System.out.println("Привет, " + имя + "!");
    }

    public static int сложить(int a, int b) {
        // 'a' и 'b' — локальные переменные
        int результат = a + b;
        return результат;
    }

    public static void вывестиИнформацию(String имя, int возраст, double балл) {
        System.out.println("Имя: " + имя);
        System.out.println("Возраст: " + возраст);
        System.out.println("Балл: " + балл);
    }

    public static void main(String[] args) {
        приветствовать("Мария");

        int сумма = сложить(5, 3);
        System.out.println("Сумма: " + сумма);

        вывестиИнформацию("Алексей", 20, 4.5);
    }
}

Имена параметров и shadowing

Параметры метода могут shadowить поля класса. Это распространённый паттерн, который требует использования this:

public class Сотрудник {
    String имя;
    int оклад;

    public void установитьИмя(String имя) {
        this.имя = имя;  // this.имя — поле класса, имя — параметр
    }

    public void установитьОклад(int оклад) {
        this.оклад = оклад;  // this.оклад — поле класса, оклад — параметр
    }

    public void показатьИнформацию() {
        System.out.println("Имя: " + this.имя);
        System.out.println("Оклад: " + this.оклад);
    }

    public static void main(String[] args) {
        Сотрудник worker = new Сотрудник();
        worker.установитьИмя("Иван");
        worker.установитьОклад(50000);
        worker.показатьИнформацию();
    }
}

Передача примитивов vs ссылочных типов

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

public class ПередачаЗначений {

    public static void изменитьПримитив(int число) {
        число = 100;  // изменяем копию
        System.out.println("Внутри метода: " + число);
    }

    public static void изменитьМассив(int[] массив) {
        массив[0] = 100;  // изменяем элемент массива
        System.out.println("Внутри метода: " + массив[0]);
    }

    public static void main(String[] args) {
        int x = 10;
        изменитьПримитив(x);
        System.out.println("После метода: " + x);  // 10 — не изменилось!

        int[] числа = {1, 2, 3};
        изменитьМассив(числа);
        System.out.println("После метода: " + числа[0]);  // 100 — изменилось!
    }
}

Примитивы (int, double, boolean) передаются по значению — метод получает копию. Массивы и объекты передаются по ссылке — метод работает с тем же объектом. Это важно понимать, когда речь заходит о побочных эффектах методов.

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

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

Ошибка 1: Использование переменной вне блока

public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
        int удвоенное = i * 2;
    }

    // ОШИБКА: cannot find symbol
    System.out.println(i);           // i не видна после цикла
    System.out.println(удвоенное);   // удвоенное не видна после цикла
}

Решение: Объявите переменную до цикла, если она нужна после него:

int i;
int удвоенное;
for (i = 0; i < 10; i++) {
    удвоенное = i * 2;
}
System.out.println(i);          // 10 — теперь доступна
System.out.println(удвоенное);  // 18 — теперь доступно

Ошибка 2: Попытка доступа к переменной из другого метода

public class Ошибки {

    public static void метод1() {
        int x = 42;
    }

    public static void метод2() {
        // ОШИБКА: cannot find symbol
        System.out.println(x);  // x объявлена в метод1, а не здесь
    }
}

Решение: Используйте параметры метода или поля класса для передачи данных между методами.

Ошибка 3: Использование неинициализированной переменной

public static void main(String[] args) {
    int результат;

    if (Math.random() > 0.5) {
        результат = 1;
    }

    // ОШИБКА: variable might not have been initialized
    System.out.println(результат);  // если условие false, результат не инициализирован
}

Решение: Всегда инициализируйте переменную при объявлении или в каждой ветви условия:

int результат = 0;  // инициализируем по умолчанию
if (Math.random() > 0.5) {
    результат = 1;
}
System.out.println(результат);  // OK

// Или используем else
int результат2;
if (Math.random() > 0.5) {
    результат2 = 1;
} else {
    результат2 = 0;
}
System.out.println(результат2);  // OK

Ошибка 4: Двойное объявление в одной области видимости

public static void main(String[] args) {
    // ОШИБКА: variable x is already defined in method main
    int x = 5;
    int x = 10;  // нельзя объявить x дважды в одном методе
}

Решение: Используйте присваивание вместо повторного объявления:

int x = 5;
x = 10;  // присваиваем новое значение

Ошибка 5: Забыли, что переменная изменилась в ветвлении

public static void main(String[] args) {
    int x = 10;

    if (x > 5) {
        int y = 20;
        x = y;  // x теперь 20
    }

    System.out.println(x);  // 20 — изменение в if сохраняется!
}

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

Lifetime переменных: от создания до уничтожения

Время жизни (lifetime) — это период существования переменной в памяти компьютера. Разные типы переменных имеют разное время жизни, и понимание этого важно для написания эффективного кода.

Время жизни локальной переменной

Локальная переменная создаётся при входе в блок (метод, if, for, while) и уничтожается при выходе из него. Память под неё выделяется на стеке вызовов (stack) и автоматически освобождается.

public static void main(String[] args) {
    {
        int x = 10;
        System.out.println(x);  // OK — x существует
    }
    // System.out.println(x);  // x уже уничтожена

    {
        int x = 20;  // новая переменная x — предыдущая уже удалена
        System.out.println(x);  // OK — новая x существует
    }
    // System.out.println(x);  // новая x тоже уничтожена
}

Время жизни instance-переменной

Instance-переменная создаётся вместе с объектом и уничтожается вместе с ним. Память под неё выделяется в куче (heap).

public class Животное {
    String кличка;  // instance-переменная

    public static void main(String[] args) {
        Животное кот = new Животное();
        кот.кличка = "Мурзик";

        Животное собака = new Животное();
        собака.кличка = "Шарик";

        System.out.println(кот.кличка);     // Мурзик
        System.out.println(собака.кличка);  // Шарик

        кот = null;  // объект "кот" больше не нужен
        // Сборщик мусора в будущем освободит память
    }
}

Время жизни static-переменной

Static-переменная создаётся при загрузке класса и уничтожается при завершении программы. Она существует на протяжении всей работы программы.

public class Счётчик {
    static int значение = 0;  // static-переменная

    public static void main(String[] args) {
        System.out.println("Начальное значение: " + значение);

        for (int i = 0; i < 5; i++) {
            значение++;
            System.out.println("Значение: " + значение);
        }

        for (int i = 0; i < 3; i++) {
            значение += 10;
        }

        System.out.println("Итого: " + значение);  // 35
    }
}

Лучшие практики работы с областью видимости

Следование лучшим практикам поможет избежать многих проблем и сделать код более читаемым и поддерживаемым.

Практика 1: Объявляйте переменные как можно ближе к месту использования

// ПЛОХО: переменная объявлена слишком рано
int x;
int y;
int z;
for (int i = 0; i < 10; i++) {
    x = i;
    y = x * 2;
    z = y + 1;
}

// ХОРОШО: переменная объявлена рядом с использованием
for (int i = 0; i < 10; i++) {
    int x = i;
    int y = x * 2;
    int z = y + 1;
}

Практика 2: Используйте понятные имена переменных

// ПЛОХО: непонятные имена
int a = 10;
int b = 20;
int c = a + b;

// ХОРОШО: информативные имена
int ширина = 10;
int высота = 20;
int площадь = ширина * высота;

Практика 3: Избегайте shadowing, если это не необходимо

public class Калькулятор {
    double результат;

    // ПЛОХО: shadowing создаёт путаницу
    public void сложить(double результат) {
        this.результат = результат;
    }

    // ХОРОШО: разные имена — код понятнее
    public void установитьРезультат(double новоеЗначение) {
        результат = новоеЗначение;
    }
}

Практика 4: Избегайте длинных методов с множеством переменных

// ПЛОХО: один длинный метод с кучей переменных
public void обработатьДанные() {
    int переменная1 = 0;
    int переменная2 = 0;
    int переменная3 = 0;
    int переменная4 = 0;
    int переменная5 = 0;
    // ... 100 строк кода ...
}

// ХОРОШО: разбиваем на маленькие методы
public void обработатьДанные() {
    int результат1 = рассчитатьПервуюЧасть();
    int результат2 = рассчитатьВторуюЧасть();
    объединить(результат1, результат2);
}

Практика 5: Инициализируйте переменные при объявлении

// ПЛОХО: переменная объявлена без инициализации
int счётчик;
// ... много кода ...
счётчик = 0;

// ХОРОШО: инициализация сразу
int счётчик = 0;

Практика 6: Минимизируйте область видимости

// ПЛОХО: переменная 'временное' используется только для проверки
int временное = 10;
if (временное > 5) {
    System.out.println("Больше пяти");
}
// временное больше нигде не используется

// ХОРОШО: используем литерал или объявляем в блоке
if (10 > 5) {
    System.out.println("Больше пяти");
}

// Или, если значение вычисляется:
int вычисленноеЗначение = вычислить();
if (вычисленноеЗначение > 5) {
    System.out.println("Больше пяти: " + вычисленноеЗначение);
}

Практика 7: Используйте effectively final переменные

// Если переменная не изменяется после инициализации — сделайте её final
final int МАКСИМАЛЬНЫЙ_РАЗМЕР = 100;
final String ПРИВЕТСТВИЕ = "Привет!";

// Это подсказывает читателю, что значение не изменится
for (int i = 0; i < МАКСИМАЛЬНЫЙ_РАЗМЕР; i++) {
    System.out.println(ПРИВЕТСТВИЕ);
}

Типичные ошибки новичков с областью видимости

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

Ошибка 1: "Переменная уже объявлена в методе"

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

public static void main(String[] args) {
    int возраст = 25;
    System.out.println(возраст);

    // ОШИБКА: cannot reuse local variable возраст
    int возраст = 30;

    // ИСПРАВЛЕНИЕ: используйте присваивание
    возраст = 30;
}

Ошибка 2: "Неинициализированная переменная"

public static void main(String[] args) {
    int результат;

    if (Math.random() > 0.5) {
        результат = 100;
    }

    // ОШИБКА: variable результат might not have been initialized
    System.out.println(результат);

    // ИСПРАВЛЕНИЕ 1: инициализировать по умолчанию
    int результат2 = 0;
    if (Math.random() > 0.5) {
        результат2 = 100;
    }
    System.out.println(результат2);

    // ИСПРАВЛЕНИЕ 2: else ветка
    int результат3;
    if (Math.random() > 0.5) {
        результат3 = 100;
    } else {
        результат3 = 0;
    }
    System.out.println(результат3);
}

Ошибка 3: "Переменная не найдена в текущей области"

public static void main(String[] args) {
    for (int i = 0; i < 5; i++) {
        int квадрат = i * i;
        System.out.println(квадрат);
    }

    // ОШИБКА: cannot find symbol
    System.out.println(i);        // i не видна
    System.out.println(квадрат);  // квадрат не видна

    // ИСПРАВЛЕНИЕ: объявить переменные до цикла
    int i2;
    int квадрат2;
    for (i2 = 0; i2 < 5; i2++) {
        квадрат2 = i2 * i2;
        System.out.println(квадрат2);
    }
    System.out.println(i2);        // 5
    System.out.println(квадрат2);  // 16
}

Ошибка 4: Путаница между локальной переменной и полем класса

public class Банк {
    double баланс = 1000;

    public void снятьДеньги(double сумма) {
        if (баланс >= сумма) {
            // ОШИБКА логики: создали локальную переменную вместо изменения поля!
            double баланс = баланс - сумма;
            System.out.println("Снято: " + сумма);
            System.out.println("Остаток: " + баланс);
        } else {
            System.out.println("Недостаточно средств");
        }
    }

    // ИСПРАВЛЕНИЕ: убрать объявление, использовать присваивание
    public void снятьДеньгиИсправленный(double сумма) {
        if (баланс >= сумма) {
            баланс = баланс - сумма;  // изменяем поле класса
            System.out.println("Снято: " + сумма);
            System.out.println("Остаток: " + баланс);
        } else {
            System.out.println("Недостаточно средств");
        }
    }
}

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

public class Класс1 {
    int x = 10;
}

public class Класс2 {
    public static void main(String[] args) {
        // ОШИБКА: cannot find symbol
        System.out.println(x);

        // ИСПРАВЛЕНИЕ: создать объект класса1
        Класс1 об = new Класс1();
        System.out.println(об.x);  // OK
    }
}

Практические примеры: объединяем всё вместе

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

Пример 1: Калькулятор

public class Калькулятор {
    double память;  // поле класса — хранит результат

    public static void main(String[] args) {
        Калькулятор калькулятор = new Калькулятор();

        калькулятор.сложить(10, 5);
        System.out.println("Результат: " + калькулятор.память);

        калькулятор.умножить(3, 4);
        System.out.println("Результат: " + калькулятор.память);
    }

    public void сложить(double a, double b) {
        память = a + b;  // сохраняем в поле класса
    }

    public void умножить(double a, double b) {
        память = a * b;
    }
}

Пример 2: Поиск в массиве

public class Поиск {

    public static int найтиИндекс(int[] массив, int искомое) {
        for (int i = 0; i < массив.length; i++) {
            if (массив[i] == искомое) {
                return i;  // нашли — возвращаем индекс
            }
        }
        return -1;  // не нашли
    }

    public static void main(String[] args) {
        int[] числа = {5, 12, 8, 3, 7};

        int индекс = найтиИндекс(числа, 8);
        if (индекс != -1) {
            System.out.println("Найдено по индексу: " + индекс);
        } else {
            System.out.println("Не найдено");
        }
    }
}

Пример 3: Программа «Угадай число»

import java.util.Random;
import java.util.Scanner;

public class УгадайЧисло {

    public static void main(String[] args) {
        Random генератор = new Random();
        Scanner сканер = new Scanner(System.in);

        int задуманное = генератор.nextInt(100) + 1;
        int попытки = 0;
        boolean угадал = false;

        System.out.println("Я загадал число от 1 до 100");

        while (!угадал) {
            System.out.print("Ваше число: ");
            int попытка = сканер.nextInt();
            попытки++;

            if (попытка == задуманное) {
                угадал = true;
                System.out.println("Верно! Вы угадали за " + попытки + " попыток");
            } else if (попытка < задуманное) {
                System.out.println("Больше!");
            } else {
                System.out.println("Меньше!");
            }
        }

        сканер.close();
    }
}

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

Продвинутые темы: область видимости и лямбда-выражения

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

Effective final переменные

Лямбда-выражения и анонимные классы могут использовать только переменные, которые не изменяются после инициализации (effectively final). Это связано с тем, что лямбда может выполняться после завершения метода, когда локальная переменная уже уничтожена.

import java.util.function.Consumer;

public class ЛямбдаОбласть {

    public static void main(String[] args) {
        String приветствие = "Привет";  // effectively final

        Consumer<String> выводить = имя -> {
            System.out.println(приветствие + ", " + имя + "!");
        };

        вывести.accept("Мария");  // Привет, Мария!

        // приветствие = "Здравствуй";  // ОШИБКА! нельзя изменять effectively final
    }
}

Область видимости в анонимных классах

public static void main(String[] args) {
    int множитель = 3;  // effectively final

    Runnable задача = new Runnable() {
        @Override
        public void run() {
            // множитель = 5;  // ОШИБКА! нельзя изменять
            System.out.println("Результат: " + (10 * множитель));
        }
    };

    задача.run();  // Выведет: Результат: 30
}

Упражнения для закрепления

Попробуйте определить, есть ли ошибки в следующих примерах, и объясните, почему:

public static void main(String[] args) {
    int x = 5;
    if (x > 0) {
        int y = x * 2;
    }
    System.out.println(y);
}

public class Тест {
    int x = 10;

    public void метод() {
        int x = 20;
        x = x + 5;
    }
}

public static void main(String[] args) {
    int результат;
    for (int i = 0; i < 10; i++) {
        результат = i * i;
    }
    System.out.println(результат);
}

public static void main(String[] args) {
    int a = 5;
    int b = 10;
    int c = a + b;
    {
        int a = 20;
    }
    System.out.println(c);
}

public class Тест {
    static int x = 1;

    public static void main(String[] args) {
        int x = 2;
        System.out.println(x);

        for (int x2 = 0; x2 < 3; x2++) {
            System.out.print(Тест.x + " ");
        }
    }
}

Сводная таблица: все типы переменных

Чек-лист: область видимости

Итоги урока

• ✅ Область видимости определяет, где переменная доступна для использования
• ✅ Локальные переменные видны только внутри метода/блока, в котором объявлены
• ✅ Поля класса (instance/static) доступны всем методам класса
• ✅ Блочная область видимости определяется фигурными скобками
• ✅ Shadowing возникает при совпадении имён локальной переменной и поля класса
• ✅ Параметры метода — это локальные переменные, которые получают значения при вызове
• ✅ Время жизни: локальные = пока блок выполняется, instance = пока объект жив, static = пока программа работает
• ✅ Объявляйте переменные как можно ближе к месту использования
• ✅ Всегда инициализируйте переменные перед использованием
• ✅ Избегайте избыточного shadowing для поддержания чистоты кода

Следующий урок

Теперь, когда вы понимаете область видимости, давайте перейдём к следующей теме — мы рассмотрим структуры данных и алгоритмы, которые опираются на правильное управление переменными.