Как компилятор определяет функциональный интерфейс

# Как компилятор определяет функциональный интерфейс

Определение функционального интерфейса

Функциональный интерфейс (Functional Interface) — это интерфейс, который содержит ровно один абстрактный метод. Компилятор Java определяет, является ли интерфейс функциональным, на основе простого правила: считает количество абстрактных методов и проверяет, равно ли оно одному.

Критерии определения функционального интерфейса

1. Один абстрактный метод

Это главное условие:

// Функциональный интерфейс ✓
@FunctionalInterface
public interface Runnable {
    void run();  // Один абстрактный метод
}

// Функциональный интерфейс ✓
public interface Comparator<T> {
    int compare(T o1, T o2);  // Один абстрактный метод
}

// НЕ функциональный интерфейс ✗
public interface MyInterface {
    void method1();  // Первый абстрактный метод
    void method2();  // Второй абстрактный метод — нарушает условие
}

2. Методы из Object класса не учитываются

Методы, унаследованные из Object, не считаются абстрактными методами интерфейса:

// Функциональный интерфейс ✓
// toString(), equals(), hashCode() из Object не считаются
public interface MyInterface {
    void doSomething();
    
    @Override
    String toString();
    
    @Override
    boolean equals(Object obj);
}

3. Статические методы и методы по умолчанию не влияют

Методы со статическим модификатором или default методы не считаются абстрактными:

// Функциональный интерфейс ✓
public interface Processor {
    void process(String input);  // Абстрактный метод (1)
    
    // Эти методы не влияют на счет абстрактных методов
    default void printResult(String result) {
        System.out.println("Result: " + result);
    }
    
    static String getVersion() {
        return "1.0";
    }
}

4. Приватные методы и константы

// Функциональный интерфейс ✓
public interface Calculator {
    // Константа (не метод)
    public static final int VERSION = 1;
    
    // Абстрактный метод
    int calculate(int a, int b);
    
    // Приватный метод (новое в Java 9)
    private void logOperation() {
        System.out.println("Operation performed");
    }
}

Аннотация @FunctionalInterface

Хотя аннотация @FunctionalInterface опциональна, она помогает компилятору проверить, что интерфейс действительно функциональный:

// Компилятор проверит, что это функциональный интерфейс
@FunctionalInterface
public interface StringProcessor {
    String process(String input);
}

// ОШИБКА компиляции! Интерфейс помечен как функциональный,
// но содержит два абстрактных метода
@FunctionalInterface
public interface InvalidInterface {  // Compilation error!
    void method1();
    void method2();
}

Как компилятор считает абстрактные методы

Алгоритм определения

// Шаг 1: Компилятор собирает все методы интерфейса
// Шаг 2: Фильтрует методы, переопределяющие public методы из Object
// Шаг 3: Считает оставшиеся абстрактные методы
// Шаг 4: Если счет = 1, это функциональный интерфейс

public interface Analysis {
    // Считается как 1 абстрактный метод
    void analyze(String data);
    
    // Переопределяет Object.toString() - не считается
    @Override
    String toString();
    
    // Переопределяет Object.equals() - не считается
    @Override
    boolean equals(Object obj);
    
    // Переопределяет Object.hashCode() - не считается
    @Override
    int hashCode();
}
// Итого: 1 абстрактный метод → Функциональный интерфейс ✓

Примеры из стандартной библиотеки

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

// java.util.function.Function<T, R>
public interface Function<T, R> {
    R apply(T t);  // Один абстрактный метод
    
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {...}
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {...}
}

// java.util.function.Predicate<T>
public interface Predicate<T> {
    boolean test(T t);  // Один абстрактный метод
    
    default Predicate<T> and(Predicate<? super T> other) {...}
    default Predicate<T> or(Predicate<? super T> other) {...}
}

// java.util.function.Consumer<T>
public interface Consumer<T> {
    void accept(T t);  // Один абстрактный метод
    
    default Consumer<T> andThen(Consumer<? super T> after) {...}
}

Использование функциональных интерфейсов

Lambda выражения

// Функциональный интерфейс
@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

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
    }
}

Method References

import java.util.function.Consumer;
import java.util.Arrays;

public class MethodReferenceExample {
    public static void main(String[] args) {
        String[] words = {"hello", "world", "java"};
        
        // Consumer<T> - функциональный интерфейс с одним методом accept(T t)
        Consumer<String> printer = System.out::println;
        Arrays.forEach(words, printer);
    }
}

Ошибки определения

Ошибка 1: Два абстрактных метода

public interface NotFunctional {
    void method1();  // Абстрактный метод 1
    void method2();  // Абстрактный метод 2
    // Компилятор: НЕ функциональный интерфейс
}

// Попытка использовать lambda
NotFunctional nf = () -> {};  // ОШИБКА компиляции!
// "The target type of this expression must be a functional interface"

Ошибка 2: Неправильная аннотация

@FunctionalInterface  // Аннотация указывает, что это функциональный интерфейс
public interface Wrong {
    void method1();
    void method2();  // Вторая абстрактный метод!
}
// ОШИБКА компиляции:
// "Multiple non-overriding abstract methods found in interface Wrong"

Поиск абстрактных методов с наследованием

// Родительский интерфейс
public interface Parent {
    void parentMethod();
}

// Дочерний интерфейс
public interface Child extends Parent {
    void childMethod();
}

// Компилятор находит 2 абстрактных метода → НЕ функциональный
// parentMethod() из Parent
// childMethod() из Child

Практический пример: Создание собственного функционального интерфейса

@FunctionalInterface
public interface StringValidator {
    // Один абстрактный метод
    boolean isValid(String input);
    
    // Default методы - не влияют
    default boolean isNotValid(String input) {
        return !isValid(input);
    }
}

public class ValidationExample {
    public static void main(String[] args) {
        // Использование lambda
        StringValidator emailValidator = 
            str -> str.contains("@") && str.contains(".");
        
        StringValidator urlValidator = 
            str -> str.startsWith("http://") || str.startsWith("https://");
        
        System.out.println(emailValidator.isValid("test@example.com"));  // true
        System.out.println(urlValidator.isValid("https://google.com"));   // true
    }
}

Заключение

Компилятор определяет функциональный интерфейс, подсчитывая количество абстрактных методов, исключая переопределения методов из Object класса. Если результат равен ровно одному абстрактному методу, интерфейс считается функциональным и может использоваться с lambda выражениями и method references. Аннотация @FunctionalInterface помогает компилятору проверить это условие и уведомить разработчика об ошибке, если критерий нарушен.