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

У интерфейса java.util.Comparator объявлено два абстрактных метода: compare(T, T) и equals(Object). Тем не менее строка Comparator<Car> byCost = (a, b) -> a.getCostUSD() - b.getCostUSD(); прекрасно компилируется, а сама аннотация @FunctionalInterface висит на Comparator совершенно законно. Понимание того, почему второй абстрактный метод «не считается», и есть ключ ко всей теме.

Функциональный интерфейс (functional interface) в Java — это интерфейс ровно с одним абстрактным методом. Такой интерфейс может быть целевым типом лямбда-выражения или ссылки на метод. Количество default-, static- и private-методов при этом не ограничено.

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

Лямбда-выражение не существует само по себе: ему всегда нужен тип. Этим типом и служит функциональный интерфейс — интерфейс с единственным абстрактным методом (SAM, Single Abstract Method).

public interface Searchable {
    boolean test(Car car);
}

Теперь интерфейс можно реализовать лямбда-выражением:

Searchable s = (Car c) -> c.getCostUSD() > 20000;
// или короче, тип параметра выводится компилятором:
Searchable s2 = c -> c.getCostUSD() > 20000;

Формально требования к функциональному интерфейсу такие:

1. Ровно один абстрактный метод.
2. Любое количество default-, static-, private- и private static-методов (последние два — начиная с Java 9).
3. Абстрактные методы, повторяющие public-методы класса Object (equals, hashCode, toString), при подсчёте не учитываются.

Пример интерфейса с default-методом — он остаётся функциональным:

interface A {
    default int defaultMethod() {
        return 0;
    }
    void method(); // единственный абстрактный метод
}

default-методов может быть сколько угодно:

interface B {
    default int defaultMethod() {
        return 0;
    }
    default int anotherDefaultMethod() {
        return 0;
    }
    private int helper() { // Java 9+
        return 42;
    }
    void method();
}

И тот самый случай с методами Object — интерфейс тоже функциональный, потому что абстрактным считается только method():

interface C {
    boolean equals(Object o);
    int hashCode();
    String toString();
    void method(); // фактически единственный абстрактный метод
}

Примеры функциональных интерфейсов из стандартной библиотеки: java.lang.Runnable, java.util.Comparator, java.util.concurrent.Callable, java.lang.Iterable. У Iterable, например, есть два default-метода (forEach и spliterator), но абстрактный по-прежнему один — iterator(). Проверять интерфейс всегда нужно по количеству именно абстрактных методов, а не всех объявленных.

2. Целевой тип: откуда лямбда узнаёт свой интерфейс

Само лямбда-выражение не содержит информации о том, какой интерфейс оно реализует. Тип выводится из контекста, в котором лямбда используется, и называется целевым типом (target type).

Целевой тип берётся из:

• объявления переменной (Searchable s = c -> ...;);
• параметра метода (list.removeIf(c -> ...));
• возвращаемого значения метода;
• приведения типа ((Searchable) c -> ...);
• тернарного оператора и инициализатора массива.

Отсюда следствие: одно и то же лямбда-выражение подходит разным интерфейсам, если сигнатуры их абстрактных методов совместимы.

interface Searchable {
    boolean test(Car car);
}
interface Saleable {
    boolean approve(Car car);
}
//...
Searchable s1 = c -> c.getCostUSD() > 20000;
Saleable   s2 = c -> c.getCostUSD() > 20000;

Обратите внимание: имена методов (test и approve) не совпадают — это неважно. Значение имеют только список параметров, тип возвращаемого значения и объявленные исключения.

По той же причине не компилируется код, в котором целевого типа нет:

// Ошибка компиляции: целевой тип неизвестен
var f = () -> System.out.println("hi");

// Ошибка компиляции: Object не функциональный интерфейс
Object o = c -> c.getCostUSD() > 20000;

3. Какие методы разрешены в функциональном интерфейсе

4. Аннотация @FunctionalInterface

В Java 8 появилась аннотация @FunctionalInterface. Она ничего не меняет в поведении программы, но заставляет компилятор проверить, что у интерфейса действительно ровно один абстрактный метод. Если это не так — сборка падает.

// Не скомпилируется: два абстрактных метода
@FunctionalInterface
interface A {
    void m(int i);
    void m(long l);
}

Аннотация необязательна: интерфейс с одним абстрактным методом является функциональным и без неё, лямбду ему присвоить можно. Но ставить её стоит — она защищает интерфейс от того, что кто-то добавит второй абстрактный метод и молча сломает весь код, где использовались лямбды.

5. Встроенные функциональные интерфейсы java.util.function

Писать свой интерфейс под каждую лямбду не нужно: в Java 8 добавлен пакет java.util.function с готовыми интерфейсами на все типовые сигнатуры.

Для примитивов существуют специализации без упаковки: IntPredicate, IntFunction<R>, ToIntFunction<T>, IntUnaryOperator, IntBinaryOperator, IntSupplier, IntConsumer и их аналоги для long и double. Они избавляют от автоупаковки в коде, который выполняется часто.

Функциональные интерфейсы есть и вне этого пакета: Runnable (void run()), Callable<V> (V call()), Comparator<T> (int compare(T, T)), Iterable<T>, AutoCloseable.

6. Что чаще всего понимают неправильно

1. «Функциональный интерфейс — это интерфейс с одним методом». Не с одним методом, а с одним абстрактным методом. default-, static- и private-методов может быть сколько угодно.
2. «Без @FunctionalInterface лямбду использовать нельзя». Можно: аннотация только включает проверку компилятора. Runnable прекрасно работал с лямбдами и до того, как получил эту аннотацию.
3. «Лямбда — это сокращённая запись анонимного класса». Нет: разное значение this, разные правила видимости и принципиально разная компиляция (см. таблицу выше).
4. «Имя метода интерфейса должно совпадать с чем-то в лямбде». Компилятор сверяет только сигнатуру: параметры, возвращаемый тип и throws. Имя абстрактного метода роли не играет.