Можно ли реализовать Lambda с помощью обычного класса?

Lambda и обычные классы

Да, полностью возможно реализовать ту же функциональность Lambda с помощью обычного класса. На самом деле, Lambda выражения в Java — это просто синтаксический сахар для создания анонимных внутренних классов, реализующих функциональные интерфейсы.

Что такое Lambda на самом деле?

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

Функциональный интерфейс

Функциональный интерфейс — это интерфейс, который содержит ровно один абстрактный метод:

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

Аннотация @FunctionalInterface — это опциональный маркер, который сообщает, что интерфейс предназначен для использования с Lambda.

Способ 1: Lambda выражение (краткий синтаксис)

public class LambdaExample {
    public static void main(String[] args) {
        // Lambda выражение
        Calculator add = (a, b) -> a + b;
        Calculator multiply = (a, b) -> a * b;
        
        System.out.println("5 + 3 = " + add.calculate(5, 3));          // 8
        System.out.println("5 * 3 = " + multiply.calculate(5, 3));    // 15
    }
}

Способ 2: Анонимный класс (эквивалент Lambda)

public class AnonymousClassExample {
    public static void main(String[] args) {
        // Анонимный класс — точный эквивалент Lambda выше
        Calculator add = new Calculator() {
            @Override
            public int calculate(int a, int b) {
                return a + b;
            }
        };
        
        Calculator multiply = new Calculator() {
            @Override
            public int calculate(int a, int b) {
                return a * b;
            }
        };
        
        System.out.println("5 + 3 = " + add.calculate(5, 3));          // 8
        System.out.println("5 * 3 = " + multiply.calculate(5, 3));    // 15
    }
}

Способ 3: Обычный класс (полный эквивалент)

// Обычный класс, реализующий функциональный интерфейс
public class AddOperation implements Calculator {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
}

public class MultiplyOperation implements Calculator {
    @Override
    public int calculate(int a, int b) {
        return a * b;
    }
}

public class ClassImplementationExample {
    public static void main(String[] args) {
        // Создание объектов обычных классов
        Calculator add = new AddOperation();
        Calculator multiply = new MultiplyOperation();
        
        System.out.println("5 + 3 = " + add.calculate(5, 3));          // 8
        System.out.println("5 * 3 = " + multiply.calculate(5, 3));    // 15
    }
}

Сравнение всех трёх подходов

import java.util.Arrays;
import java.util.List;

public class ComparisonExample {
    
    @FunctionalInterface
    interface StringProcessor {
        String process(String input);
    }
    
    // === ПОДХОД 1: Lambda (самый компактный) ===
    public static void lambdaApproach() {
        StringProcessor toUpper = str -> str.toUpperCase();
        StringProcessor reverse = str -> new StringBuilder(str).reverse().toString();
        
        System.out.println(toUpper.process("hello"));      // HELLO
        System.out.println(reverse.process("hello"));      // olleh
    }
    
    // === ПОДХОД 2: Анонимный класс ===
    public static void anonymousApproach() {
        StringProcessor toUpper = new StringProcessor() {
            @Override
            public String process(String input) {
                return input.toUpperCase();
            }
        };
        
        StringProcessor reverse = new StringProcessor() {
            @Override
            public String process(String input) {
                return new StringBuilder(input).reverse().toString();
            }
        };
        
        System.out.println(toUpper.process("hello"));      // HELLO
        System.out.println(reverse.process("hello"));      // olleh
    }
    
    // === ПОДХОД 3: Обычные классы ===
    static class ToUpperProcessor implements StringProcessor {
        @Override
        public String process(String input) {
            return input.toUpperCase();
        }
    }
    
    static class ReverseProcessor implements StringProcessor {
        @Override
        public String process(String input) {
            return new StringBuilder(input).reverse().toString();
        }
    }
    
    public static void classApproach() {
        StringProcessor toUpper = new ToUpperProcessor();
        StringProcessor reverse = new ReverseProcessor();
        
        System.out.println(toUpper.process("hello"));      // HELLO
        System.out.println(reverse.process("hello"));      // olleh
    }
    
    public static void main(String[] args) {
        System.out.println("=== Lambda approach ===");
        lambdaApproach();
        
        System.out.println("\n=== Anonymous class approach ===");
        anonymousApproach();
        
        System.out.println("\n=== Regular class approach ===");
        classApproach();
    }
}

Практический пример: обработка коллекций

import java.util.Arrays;
import java.util.List;

public class ListProcessingExample {
    
    interface Validator {
        boolean validate(String value);
    }
    
    public static void main(String[] args) {
        List<String> emails = Arrays.asList(
            "user@example.com",
            "invalid.email",
            "admin@company.com",
            "test@domain.io"
        );
        
        // Lambda подход
        System.out.println("=== Валидация через Lambda ===");
        Validator emailValidator = email -> email.contains("@");
        emails.stream()
              .filter(emailValidator::validate)
              .forEach(System.out::println);
        
        // Класс подход
        System.out.println("\n=== Валидация через класс ===");
        Validator classValidator = new EmailValidator();
        emails.stream()
              .filter(classValidator::validate)
              .forEach(System.out::println);
    }
}

class EmailValidator implements ListProcessingExample.Validator {
    @Override
    public boolean validate(String value) {
        return value.contains("@");
    }
}

Когда использовать что?

Заключение

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