Представьте, что ваша программа — это дом. А переменные — это вещи, которые хранятся в комнатах. В каждой комнате (блоке кода) свои правила: вы можете взять вещи только те, что лежат в этой комнате или в коридоре (внешнем блоке). В других комнатах — они недоступны.
Сегодня мы разберёмся:
- Как устроены блоки кода в Java
- Как переменные живут и умирают
- Что можно, а чего нельзя делать с переменными
- Как вложенность блоков влияет на область видимости
🔍 Что такое переменная?
Переменная — это имя для значения, которое мы можем изменять в процессе выполнения программы. Это как ярлык, приклеенный к коробке.
String name = "Alice";
Здесь:
- String — тип данных (строка)
- name — имя переменной
- "Alice" — значение
🧱 Блоки кода — что это такое?
В Java блок кода всегда ограничен фигурными скобками {}. Блоки появляются:
- В методах (main, printInfo, и т. д.)
- В условных операторах (if, else)
- В циклах (for, while)
- Просто так — чтобы сгруппировать код
{
int number = 42;
System.out.println(number);
}
Такой блок можно создать где угодно внутри метода — Java позволяет.
🌐 Область видимости переменной (scope)
Область видимости — это «территория», где переменная доступна для использования.
Пример:
public static void main(String[] args) {
int a = 5; // доступна в main
{
int b = a + 10; // доступна только в этом блоке
System.out.println("b = " + b);
}
// System.out.println(b); // Ошибка: b вне видимости
}
📌 Переменная a доступна в любом вложенном блоке. А b — нет, она исчезает после выхода из блока.
⏳ Время жизни переменной (lifetime)
- Локальная переменная: создаётся при входе в блок и уничтожается при выходе.
- Глобальная (класс-уровень): живёт всё время, пока программа работает.
Пример глобальной переменной:
public class App {
static int counter = 0; // глобальная переменная
public static void main(String[] args) {
counter++;
System.out.println("counter = " + counter);
}
}
⚠️ Ошибки, связанные с переменными
1. Использование переменной вне её области:
public static void main(String[] args) {
{
int temp = 99;
}
// System.out.println(temp); // Ошибка!
}
2. Повторное объявление переменной в одном блоке:
int x = 10;
// int x = 20; // Ошибка! Уже объявлена
🧬 Вложенные блоки: как они работают
Вложенные блоки — это блоки внутри других блоков. И здесь действует правило: внутренний блок видит переменные внешнего, но не наоборот.
Пример:
public static void main(String[] args) {
int outer = 1;
{
int inner = outer + 1;
System.out.println("inner = " + inner); // OK
}
// System.out.println(inner); // Ошибка!
}
📝 Тест: проверь себя
1. Где переменная видна, если она объявлена внутри блока {}?
A. В любом месте программы
B. Только в методе
C. Только внутри этого блока и его вложенных блоках
D. После выхода из блока
2. Что произойдёт, если объявить две переменные с одинаковым именем в одном блоке?
A. Скомпилируется, но с предупреждением
B. Ошибка компиляции
C. Первая переменная будет удалена
D. Java выберет переменную с большим значением
3. Какая переменная живёт всё время выполнения программы?
A. Локальная
B. Глобальная (переменная класса)
C. Вложенная
D. Временная
🎯 Практические задачи
Задача 1.
Создайте глобальную переменную int counter = 100, и увеличьте её значение внутри метода main() на 1. Выведите результат.
Задача 2.
Создайте блок кода внутри main, в котором создаётся переменная double temp = 36.6. Попробуйте вывести её после этого блока — получите ошибку. Объясните, почему.
Задача 3.
Напишите код, в котором во внешнем блоке создаётся переменная int x = 3, а во вложенном блоке создаётся int y = x + 2. Выведите обе переменные в консоль.
🏁 Заключение
Теперь вы знаете:
- Что такое блоки кода и зачем они нужны
- Где переменные «живут» и «умирают»
- Как работает область видимости
- Что нельзя использовать переменные вне их блока
- Почему вложенные блоки видят переменные внешнего блока, но не наоборот
Это базовые знания, но они лежат в основе всего Java-кода. Уверенно двигайтесь дальше — впереди ещё много интересного!
✅ Ответы на тест
- Где переменная видна, если она объявлена внутри блока {}?
✅ Правильный ответ: C. Только внутри этого блока и его вложенных блоках - Что произойдёт, если объявить две переменные с одинаковым именем в одном блоке?
✅ Правильный ответ: B. Ошибка компиляции - Какая переменная живёт всё время выполнения программы?
✅ Правильный ответ: B. Глобальная (переменная класса)
🔍 Подробный разбор задач
🔹 Задача 1. Глобальная переменная
public class GlobalExample {
static int counter = 100;
public static void main(String[] args) {
counter++;
System.out.println("counter = " + counter); // counter = 101
}
}
🔍 Пояснение:
- counter доступен во всём классе.
- Его значение увеличивается на 1 внутри метода main.
🔹 Задача 2. Ошибка области видимости
public class ScopeError {
public static void main(String[] args) {
{
double temp = 36.6;
}
// System.out.println(temp); // Ошибка: temp вне видимости
}
}
🔍 Пояснение:
- temp живёт только внутри блока {}.
- После блока она уничтожается — ссылка на неё невозможна.
🔹 Задача 3. Вложенный блок
public class NestedScope {
public static void main(String[] args) {
int x = 3;
{
int y = x + 2;
System.out.println("x = " + x); // x = 3
System.out.println("y = " + y); // y = 5
}
}
}
🔍 Пояснение:
- Внутренний блок может использовать x из внешнего.
- Переменная y живёт только внутри вложенного блока.