Functional Interface in Java

The interface java.util.Comparator declares two abstract methods: compare(T, T) and equals(Object). Yet the line Comparator<Car> byCost = (a, b) -> a.getCostUSD() - b.getCostUSD(); compiles without a complaint, and the @FunctionalInterface annotation sits on Comparator perfectly legally. Understanding why that second abstract method does not count is the key to this whole topic.

A functional interface in Java is an interface with exactly one abstract method. Such an interface can serve as the target type of a lambda expression or a method reference. The number of default, static and private methods is not limited.

1. What is a functional interface

A lambda expression does not exist on its own: it always needs a type. That type is a functional interface — an interface with a single abstract method, also called a SAM interface (Single Abstract Method). The single abstract method itself is called the functional method.

Example 1. Declaring a functional interface

@FunctionalInterface
public interface SomeInterface {
    void doSomething();
}

Now the interface can be implemented by a lambda expression instead of a class:

SomeInterface task = () -> System.out.println("done");
task.doSomething(); // prints: done

The formal requirements are:

1. Exactly one abstract method.
2. Any number of default, static, private and private static methods (the last two are allowed since Java 9).
3. Abstract declarations that repeat the public methods of java.lang.Object (equals, hashCode, toString) are not counted.

An interface with a default method is still functional:

interface A {
    default int defaultMethod() {
        return 0;
    }
    void method(); // the only abstract method
}

There may be as many non-abstract methods as you like:

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

And here is the Object case from the opening — the interface is functional, because only method() counts as abstract:

interface C {
    boolean equals(Object o);
    int hashCode();
    String toString();
    void method(); // effectively the only abstract method
}

The JDK is full of interfaces with a single abstract method: java.lang.Runnable, java.util.concurrent.Callable, java.util.Comparator, java.awt.event.ActionListener, java.lang.Iterable. They did not change in Java 8 — the language did. Since Java 8 any such interface can be the target type of a lambda expression, and most of them were annotated with @FunctionalInterface to lock that contract in. Iterable, for instance, gained two default methods (forEach and spliterator), but its only abstract method is still iterator(), so it stays functional. Always judge an interface by the number of abstract methods, not by the number of declared ones.

2. Function descriptor

The term function descriptor describes the signature of the functional method — and therefore the shape of any lambda expression that can implement it. The notation is parameters -> return type: parameter types on the left of the arrow, the result type on the right. The method name is not part of the descriptor.

SomeInterface from Example 1 has the method doSomething(), which takes no parameters and returns void. Its function descriptor is () -> void.

Example 2. One parameter, a value returned

@FunctionalInterface
public interface SomeInterface1 {
    int someMethod1(String param);
}

The function descriptor is String -> int, so the lambda must accept a string and return an int:

SomeInterface1 length = s -> s.length();

Example 3. Two parameters, no result

@FunctionalInterface
public interface SomeInterface2 {
    void someMethod2(int a1, int a2);
}

The function descriptor is (int, int) -> void.

Example 4. Function descriptor of the Consumer interface

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
    // plus default methods, for example andThen(Consumer<? super T> after)
}

The function descriptor of Consumer is T -> void.

3. Target type: how a lambda learns its interface

A lambda expression carries no information about the interface it implements. The compiler infers that type from the context in which the lambda appears, and this context type is called the target type.

The target type comes from:

• a variable declaration (Searchable s = c -> ...;);
• a method parameter (list.removeIf(c -> ...));
• a method return statement;
• a cast ((Searchable) c -> ...);
• a ternary expression or an array initializer.

Consequently, the same lambda body fits different interfaces as long as the descriptors of their functional methods match:

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

Note that the method names (test and approve) differ, and it does not matter. Only the parameter list, the return type and the declared exceptions are compared.

For the same reason, code without a target type does not compile:

// Compile error: the target type cannot be inferred
var f = () -> System.out.println("hi");

// Compile error: Object is not a functional interface
Object o = c -> c.getCostUSD() > 20000;

4. Which methods are allowed in a functional interface

5. The @FunctionalInterface annotation

Java 8 introduced the @FunctionalInterface annotation. It changes nothing at runtime, but it makes the compiler verify that the interface really has exactly one abstract method. If it does not, the build fails.

// Does not compile: two abstract methods
@FunctionalInterface
interface A {
    void m(int i);
    void m(long l);
}

The annotation is optional: an interface with a single abstract method is functional without it, and a lambda can be assigned to it anyway. Still, it is worth adding — it protects the interface from someone quietly adding a second abstract method and breaking every lambda that relied on it.

6. Built-in functional interfaces of java.util.function

You rarely need to declare your own interface for every lambda: Java 8 added the java.util.function package with ready-made interfaces for the common signatures.

For primitives there are specializations that avoid boxing: IntPredicate, IntFunction<R>, ToIntFunction<T>, IntUnaryOperator, IntBinaryOperator, IntSupplier, IntConsumer and their long and double counterparts. They pay off in code that runs often.

Functional interfaces also live outside this package: Runnable (void run()), Callable<V> (V call()), Comparator<T> (int compare(T, T)), Iterable<T> and AutoCloseable.

7. Common misconceptions

1. "A functional interface is an interface with one method." Not one method — one abstract method. There may be any number of default, static and private methods.
2. "Without @FunctionalInterface you cannot use a lambda." You can: the annotation only enables a compiler check. Runnable worked fine with lambdas before it was annotated.
3. "A lambda is shorthand for an anonymous class." No: different this, different scoping rules and a fundamentally different compilation strategy (see the table above).
4. "The lambda must somehow match the method name." The compiler compares the signature only: parameters, return type and throws. The name of the abstract method plays no role.