Для чего нуден effectivelly final

Effectively Final в Java

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

Что такое Effectively Final

"Effectively Final" означает, что переменная никогда не изменяется после инициализации, хотя она явно не объявлена как final. В Java 8+ компилятор распознаёт такие переменные и позволяет их использовать в лямбда выражениях и анонимных классах.

Правило: Localy captured переменные должны быть Final или Effectively Final

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

• Явно объявлена как final
• ИЛИ быть "effectively final" (не изменяться после первого присваивания)

Пример 1: Не effectively final (ОШИБКА)

public void demonstrateNotEffectivelyFinal() {
    int count = 0;  // Локальная переменная
    
    // Попытка использовать в лямбде
    List<Integer> numbers = Arrays.asList(1, 2, 3);
    
    // ❌ ОШИБКА КОМПИЛЯЦИИ
    numbers.forEach(n -> {
        System.out.println(count + n);  // count не effectively final!
    });
    
    count++;  // Изменяем переменную - она больше не effectively final
}

Причина ошибки: После того как count изменяется (count++), переменная больше не является "effectively final", поэтому лямбда не может её использовать.

Пример 2: Effectively final (РАБОТАЕТ)

public void demonstrateEffectivelyFinal() {
    int count = 0;  // Локальная переменная
    
    // count никогда не изменяется после инициализации
    List<Integer> numbers = Arrays.asList(1, 2, 3);
    
    // ✅ РАБОТАЕТ - count является effectively final
    numbers.forEach(n -> {
        System.out.println(count + n);  // count effectively final
    });
    
    // count++;  // Это бы сделало её неeffectively final
}

Пример 3: Явное объявление final

public void demonstrateExplicitFinal() {
    final int count = 0;  // Явно final
    
    List<Integer> numbers = Arrays.asList(1, 2, 3);
    
    // ✅ РАБОТАЕТ - явно объявлена как final
    numbers.forEach(n -> {
        System.out.println(count + n);
    });
    
    // count++;  // ОШИБКА КОМПИЛЯЦИИ - нельзя изменить final переменную
}

Пример 4: Effectively final объекты

public void demonstrateObjectEffectivelyFinal() {
    Person person = new Person("John", 25);  // Effectively final
    
    List<String> activities = Arrays.asList("reading", "coding");
    
    // ✅ РАБОТАЕТ - переменная person не изменяется
    activities.forEach(activity -> {
        System.out.println(person.getName() + " likes " + activity);
    });
    
    // ❌ Это сделало бы её не effectively final
    // person = new Person("Jane", 30);
}

Важно: Можно изменять СОДЕРЖИМОЕ объекта (person.setAge(26)), но саму переменную person нельзя переназначивать.

Пример 5: Анонимные классы (до лямбд)

public void demonstrateAnonymousClass() {
    String message = "Hello";  // Effectively final
    
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println(message);  // message effectively final
        }
    };
    
    // message = "Goodbye";  // Ошибка - переменная перестаёт быть effectively final
}

Пример 6: Сложный случай со Stream API

public void streamWithEffectivelyFinal() {
    List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
    String prefix = "Mr. ";  // Effectively final
    
    names.stream()
        .map(name -> prefix + name)  // prefix effectively final
        .forEach(System.out::println);
    
    // prefix = "Ms. ";  // Делает переменную не effectively final
}

Почему это нужно?

1. Избежание ошибок с замыканиями (Closure)

// Без требования effectively final
List<Callable<Integer>> callables = new ArrayList<>();

for (int i = 0; i < 3; i++) {
    callables.add(() -> i);  // ❌ Какое значение вернёт i?
}

// Все будут возвращать последнее значение i = 3
for (Callable<Integer> c : callables) {
    System.out.println(c.call());  // Выведет 3, 3, 3
}

// С effectively final
List<Callable<Integer>> callables2 = new ArrayList<>();

for (int i = 0; i < 3; i++) {
    final int value = i;  // Создаём отдельную final переменную
    callables2.add(() -> value);  // Теперь правильно
}

2. Потокобезопасность

public void threadSafetyExample() throws InterruptedException {
    int data = 42;  // Effectively final
    
    new Thread(() -> {
        // Гарантия: data не может быть изменена другим потоком
        System.out.println("Data: " + data);
    }).start();
    
    // data = 100;  // Ошибка - нарушит effectively final
}

Практический пример: Collector с effectively final

public Map<String, List<Integer>> groupByEffectivelyFinal() {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    String prefix = "number_";  // Effectively final
    int threshold = 3;  // Effectively final
    
    return numbers.stream()
        .collect(Collectors.groupingBy(
            n -> n > threshold ? (prefix + "large") : (prefix + "small")
        ));
    
    // Результат:
    // number_small -> [1, 2, 3]
    // number_large -> [4, 5]
}

Различие: final vs effectively final

// 1. final - явное объявление
final String name = "John";
name = "Jane";  // ОШИБКА КОМПИЛЯЦИИ

// 2. effectively final - неявное
String city = "Moscow";
city = "SPB";  // Ошибка ТОЛЬКО если использовать в лямбде/анонимном классе

List<String> list = Arrays.asList("a");
list.forEach(x -> System.out.println(city + x));  // ОШИБКА до изменения
city = "SPB";  // ТЕПЕРЬ перестаёт быть effectively final

Когда появилось (История)

• Java 7 и ранее: Требование явного final для локальных переменных в анонимных классах
• Java 8: Введено понятие "effectively final" для упрощения работы с лямбдами
• Java 9+: Правило остаётся, но применяется и к другим контекстам

Практическое применение

@FunctionalInterface
interface Formatter {
    String format(String input);
}

public Formatter createFormatter() {
    String template = "[%s]";  // Effectively final
    
    return input -> String.format(template, input);
    // template используется в лямбде и переносится в замыкание
}

public static void main(String[] args) {
    Formatter formatter = createFormatter();
    System.out.println(formatter.format("hello"));  // [hello]
}

Частая ошибка

// ❌ Неправильно
for (int i = 0; i < 3; i++) {
    Thread thread = new Thread(() -> {
        System.out.println(i);  // ОШИБКА: i не effectively final
    });
    thread.start();
}

// ✅ Правильно
for (int i = 0; i < 3; i++) {
    final int finalI = i;  // Создаём отдельную final переменную
    Thread thread = new Thread(() -> {
        System.out.println(finalI);  // Теперь OK
    });
    thread.start();
}

Заключение

Effectively final в Java — это требование компилятора, которое:

1. Предотвращает ошибки — с замыканиями и областью видимости
2. Обеспечивает потокобезопасность — гарантирует неизменность захватываемых переменных
3. Упрощает код — не нужно везде писать explicit final
4. Работает с лямбдами — делает использование функциональных выражений безопаснее

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