Устарели ли анонимные классы с выходом Java 8

Анонимные классы vs Lambda в современной Java

Модно сказать, что анонимные классы полностью устарели, но на самом деле это более нюансированная ситуация. Оба подхода сосуществуют, каждый с своим применением.

Что произошло с Java 8

Java 8 принесла lambda expressions как синтаксический сахар для functional interfaces (интерфейсы с одним методом).

// ДО Java 8 - анонимный класс
Button button = new Button();
button.setOnClickListener(new Button.OnClickListener() {
    @Override
    public void onClick() {
        System.out.println("Clicked");
    }
});

// ПОСЛЕ Java 8 - lambda expression
button.setOnClickListener(() -> System.out.println("Clicked"));

Для functional interfaces - lambda лучше

Лambda значительно чище для интерфейсов с одним методом:

// Functional interface
@FunctionalInterface
public interface PaymentProcessor {
    void process(Order order);
}

// ПЛОХО - анонимный класс
PaymentProcessor processor = new PaymentProcessor() {
    @Override
    public void process(Order order) {
        System.out.println("Processing: " + order.getId());
    }
};

// ХОРОШО - lambda
PaymentProcessor processor = order -> System.out.println("Processing: " + order.getId());

// ЕЩЕ ЛУЧШЕ - method reference
PaymentProcessor processor = System.out::println;

Но анонимные классы НЕ устарели

Есть сценарии, где анонимные классы необходимы:

1. Многометодные интерфейсы

Lambda работает только для интерфейсов с одним методом. Если интерфейс имеет несколько методов - только анонимный класс:

// MouseListener имеет 5 методов - нельзя lambda
public class MouseListenerExample {
    public void setupListener(Component component) {
        component.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                handleClick(e);
            }
            
            @Override
            public void mouseMoved(MouseEvent e) {
                handleMove(e);
            }
        });
    }
}

2. Доступ к this и super

В lambda this указывает на enclosing класс. В анонимном классе this указывает на сам класс:

public class OuterClass {
    private String outerField = "outer";
    
    public void createListener() {
        // В lambda - this это OuterClass
        Runnable r1 = () -> System.out.println(this.outerField);
        
        // В анонимном классе - this это AnonymousClass
        Runnable r2 = new Runnable() {
            @Override
            public void run() {
                // this - это анонимный класс, нет своего поля
                System.out.println(OuterClass.this.outerField);
            }
        };
    }
}

3. Инициализаторы и состояние

Анонимный класс может иметь поля и инициализаторы:

// Анонимный класс с состоянием
Comparator<User> comparator = new Comparator<User>() {
    private final DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
    
    @Override
    public int compare(User u1, User u2) {
        return u1.getCreatedAt().compareTo(u2.getCreatedAt());
    }
};

// Lambda не может иметь состояние (только переменные из enclosing scope)
Comparator<User> comparator2 = (u1, u2) -> {
    // Не могу иметь здесь собственные поля
    return u1.getCreatedAt().compareTo(u2.getCreatedAt());
};

4. Конструкторы с логикой

Анонимный класс может иметь инициализирующий блок:

public class StatefulListener extends EventListener {
    private State state;
    
    public void addListener() {
        component.addListener(new EventListener() {
            private int callCount = 0;
            
            {
                // Инициализирующий блок
                System.out.println("Listener initialized");
            }
            
            @Override
            public void onEvent(Event e) {
                callCount++;
                System.out.println("Event #" + callCount);
            }
        });
    }
}

Производительность

Do Java 8 анонимные классы создавали новый класс для каждого экземпляра. Lambda использует более эффективный механизм:

// Анонимный класс - один .class файл на использование
// Lambda - переиспользуется, bytecode оптимизирован

// В Java 11+ - records еще более эффективны для простых данных
record PaymentData(String id, BigDecimal amount) {}

Практический выбор

Если нужно:
├─ Реализовать functional interface  → Lambda
├─ Множество методов                → Анонимный класс
├─ Собственное состояние            → Анонимный класс
├─ Инициализацию и setup            → Анонимный класс
├─ Простой callback                 → Lambda
└─ Inheritance логика              → Именованный класс

Мой реальный опыт

В последнем проекте:

// Collections API - везде lambda
list.stream()
    .filter(x -> x.isActive())
    .map(x -> x.getName())
    .forEach(System.out::println);

// Event listeners в UI - смешано
// Простые: lambda
button.setOnClick(() -> saveData());

// Сложные (MouseListener, KeyListener): анонимные классы
component.addMouseListener(new MouseAdapter() {
    @Override
    public void mouseClicked(MouseEvent e) { ... }
    
    @Override
    public void mouseMoved(MouseEvent e) { ... }
});

// Custom implementations - именованные классы
public class UserRepository implements Repository<User> {
    @Override
    public User findById(UUID id) { ... }
    
    @Override
    public List<User> findAll() { ... }
}

Вывод

Анонимные классы НЕ устарели, a переместились в нишу. Lambda идеальна для functional interfaces и callbacks, но анонимные классы остаются необходимы для:

• Интерфейсов с несколькими методами
• Сложной инициализации
• Управления состоянием
• Когда нужно разместить логику сразу на месте

Правильный подход - использовать правильный инструмент для каждой задачи, а не слепо заменять все lambda.