@FunctionalInterface: примеры (JAVA)

Простые примеры использования

Ниже приведены простые варианты использования аннотации и соответствующие результаты при запуске.

Пример 1: базовый функциональный интерфейс и лямбда

@FunctionalInterface
interface Greeting {
    void say(String name);
}

public class Main {
    public static void main(String[] args) {
        Greeting g = name -> System.out.println("Hello, " + name);
        g.say("World");
    }
}

Hello, World

Пример 2: функциональный интерфейс с возвращаемым значением и generics

@FunctionalInterface
interface Converter {
    T convert(F from);
}

public class Main {
    public static void main(String[] args) {
        Converter c = Integer::valueOf;
        System.out.println(c.convert("123") + 1);
    }
}

124

Пример 3: default и static методы не нарушают функциональность

@FunctionalInterface
interface Accumulator {
    int add(int a, int b);

    default int addAll(int[] arr) {
        int s = 0;
        for (int v : arr) s += v;
        return s;
    }

    static Accumulator of() {
        return Integer::sum;
    }
}

public class Main {
    public static void main(String[] args) {
        Accumulator acc = Accumulator.of();
        System.out.println(acc.add(2, 3));
        System.out.println(acc.addAll(new int[]{1,2,3}));
    }
}

5
6

Аналоги и связанные механизмы в Java

Внутри Java нет прямой «альтернативы» самой аннотации, но есть несколько подходов, которые выполняют схожие задачи:

• Отсутствие аннотации - можно не помечать интерфейс @FunctionalInterface. Java поддерживает SAM-конверсию и без аннотации; аннотация служит для явности и проверки компилятора.
• Готовые функциональные интерфейсы из пакета java.util.function (Function, Consumer, Supplier, Predicate и примитивные специализации). Предпочтительнее использовать их при работе с общими функциями, чтобы избежать лишних types и повысить читаемость API.
• Анонимные классы - более многословные, но позволяют реализовать интерфейс без лямбд и применимы, если нужен явный класс с состоянием.

Выбор зависит от читабельности и семантики: для простых операций удобнее использовать стандартные интерфейсы java.util.function; для доменных концепций выгодно объявлять собственные интерфейсы с @FunctionalInterface.

Аналоги в других языках и отличия

Краткое сравнение с механизмами в других языках и примеры.

JavaScript - first-class функции

// JS
const greet = name => `Hello, ${name}`;
console.log(greet('Alice'));

Hello, Alice

Отличие: никаких явных интерфейсов или аннотаций, функции являются объектами первого класса.

Python - callables и протоколы

# Python
def add(a, b):
    return a + b
print(add(2,3))

5

Отличие: динамическая типизация, нет статической проверки SAM, но возможны typing.Protocol для похожих контрактов.

C# - делегаты и Func/Action

// C#
using System;

Func<int,int,int> sum = (a,b) => a + b;
Console.WriteLine(sum(2,3));

5

Отличие: делегаты встроены в язык как типы, синтаксис и семантика ближе к Java functional interfaces, но без отдельной аннотации.

Kotlin - функциональные типы и SAM-конверсии

// Kotlin
val f: (Int, Int) -> Int = { a, b -> a + b }
println(f(2,3))

5

Отличие: в Kotlin функции - полноценные типы, SAM-конверсия поддерживается для Java-интерфейсов и функциональных типов.

Go - типы функций

// Go
package main
import "fmt"
func sum(a, b int) int { return a + b }
func main(){ fmt.Println(sum(2,3)) }

5

Отличие: простая статическая типизация, функции как значения, отсутствует аннотированный интерфейсный контракт SAM.

PHP - callables

// PHP
$add = fn($a,$b) => $a + $b;
echo $add(2,3);

5

Lua - функции как значения

-- Lua
local function add(a,b) return a+b end
print(add(2,3))

5

Вывод: большинство языков предлагают функции как значения, но Java выделяется строгой интерфейсной моделью и необходимостью объявлять контракт интерфейса для SAM-конверсии; @FunctionalInterface - лишь удобный механизм документирования и строгой проверки такого контракта.

Типичные ошибки и примеры

Ошибки, связанные с применением аннотации и функциональных интерфейсов.

Ошибка 1: интерфейс с более чем одним абстрактным методом

@FunctionalInterface
interface Bad {
    void a();
    void b();
}

// Компиляция выдаст ошибку: интерфейс помечен как FunctionalInterface,
// но содержит более одного абстрактного метода.

error: Unexpected @FunctionalInterface annotation
interface Bad {
^

Ошибка 2: недопустимая сигнатура при попытке использовать метод-референс

@FunctionalInterface
interface ToInt {
    int apply(String s);
}

public class Main {
    public static void main(String[] args) {
        // Integer::parseInt подходит
        ToInt t1 = Integer::parseInt; // OK
        // String::length не подходит, потому что возвращает int но принимает no-arg
        ToInt t2 = String::length; // Ошибка компиляции
    }
}

error: incompatible types: bad return type in method reference
        ToInt t2 = String::length;
                   ^

Ошибка 3: попытка изменить захваченную переменную из лямбды

public class Main {
    public static void main(String[] args) {
        int x = 1;
        Runnable r = () -> {
            // x = 2; // ошибка: x должен быть effectively final
            System.out.println(x);
        };
        r.run();
    }
}

Если раскомментировать присваивание, то будет ошибка компиляции: local variables referenced from a lambda expression must be final or effectively final

Ошибка 4: объявление абстрактного метода, совпадающего с методом Object и пометка как второй абстрактный

@FunctionalInterface
interface Strange {
    boolean equals(Object o); // не считается дополнительным абстрактным методом
    void doIt(); // единственный SAM
}

Пояснение: методы из Object не увеличивают число абстрактных методов, поэтому equals не ломает контракт, но осознанность важна.

Изменения и история

Аннотация и поддержка функциональных интерфейсов появились в Java 8 вместе с лямбда-выражениями и Stream API. С момента введения:

• Java 8: введены @FunctionalInterface, лямбды, default и static методы в интерфейсах.
• Java 9 и далее: добавлены private методы в интерфейсах, которые также не нарушают статус функционального интерфейса.
• Последующие релизы не вносили существенных изменений в саму аннотацию @FunctionalInterface; развивались сопутствующие API: расширения стандартных функциональных интерфейсов, улучшения JIT и сериализации лямбд в некоторых реализациях.

Итог: семантика аннотации осталась стабильной с Java 8 по текущие версии; изменений в сигнатуре аннотации не происходило.

Расширенные и редкие варианты использования

Несколько продвинутых сценариев с пояснениями и результатами.

1. Функциональный интерфейс, бросающий проверяемое исключение

@FunctionalInterface
interface IOFunction {
    R apply(T t) throws Exception;
}

public class Main {
    public static void main(String[] args) {
        IOFunction f = s -> Integer.parseInt(s);
        try {
            System.out.println(f.apply("10") + 5);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

15

Пояснение: иногда полезно объявлять SAM с throws для интеграции с кодом, требующим обработки checked-исключений.

2. Композиция функций и вспомогательные методы

@FunctionalInterface
interface Func {
    R apply(T t);

    default <V> Func<V, R> compose(Func<V, T> before) {
        return v -> apply(before.apply(v));
    }
}

public class Main {
    public static void main(String[] args) {
        Func<String, Integer> parse = Integer::valueOf;
        Func<Integer, Integer> square = x -> x * x;
        Func<String, Integer> parseThenSquare = square.compose(parse);
        System.out.println(parseThenSquare.apply("5"));
    }
}

25

Пояснение: добавление default-методов для композиции делает интерфейс удобным для функционального программирования в стиле fluent.

3. Использование с CompletableFuture и метод-референсами

import java.util.concurrent.*;

@FunctionalInterface
interface Processor {
    String process(int x);
}

public class Main {
    public static String toStr(int x) { return "x=" + x; }
    public static void main(String[] args) throws Exception {
        Processor p = Main::toStr;
        CompletableFuture.supplyAsync(() -> p.process(7))
            .thenAccept(System.out::println)
            .get();
    }
}

x=7

4. Инспекция аннотации через рефлексию

@FunctionalInterface
interface A { void a(); }

public class Main {
    public static void main(String[] args) {
        boolean present = A.class.isAnnotationPresent(java.lang.FunctionalInterface.class);
        System.out.println(present);
    }
}

true

5. Применение к generic-интерфейсу с примитивными специализациями

@FunctionalInterface
interface ToIntFunc { int applyAsInt(T t); }

public class Main {
    public static void main(String[] args) {
        ToIntFunc<String> len = String::length;
        System.out.println(len.applyAsInt("Hello"));
    }
}

5

6. Совместимость с сериализацией (редкий сценарий)

@FunctionalInterface
interface SFunc extends java.io.Serializable { int f(int x); }

public class Main {
    public static void main(String[] args) {
        SFunc sf = x -> x * 2;
        // Можно сериализовать объект-лямбду в некоторых JVM, но поведение зависит от реализации
        System.out.println(sf.f(4));
    }
}

8

Пояснение: лямбды могут быть сериализуемыми при явном наследовании от Serializable, но переносимость таких сериализованных объектов между версиями JVM не гарантируется.