What Is a Functional Interface?

A functional interface is an interface with exactly one abstract method. Everything else in it may be default methods, static methods or constants. The single abstract method is called the single abstract method, or SAM, and it is what a lambda implements.

The compiler works it out by counting the abstract methods. If there is exactly one, the interface is a functional interface and a lambda is a valid implementation of it. If there are zero — an interface with only default methods — it is not a functional interface, and no lambda can be assigned to it. If there are two or more, it is not one either, and the compiler rejects the lambda assignment.

The @FunctionalInterface annotation is optional in the language but worth always adding. It is a compile-time check: if somebody later adds a second abstract method to the interface, every lambda that implemented it stops compiling, and the annotation turns that into a clear error at the interface itself rather than a confusing cascade of errors at every use site.

Two consequences of the SAM rule are worth knowing. Because the method is unique, the compiler can treat the interface as a function type and you can pass implementations around without declaring a separate class. And because the interface has a single method, the inherited methods from Object — equals, hashCode and toString — do not count towards the total. An interface with one method plus those three is still a functional interface.

The practical note: a functional interface describes one operation, so name it after that operation rather than after the implementation. Naming it Consumer or Transformer rather than ServiceProcessor makes it obvious that it is meant to be implemented by a lambda.

A default method is a method with a body declared in the interface. Every implementation inherits it and may override it. A static method belongs to the interface itself and is called on the interface rather than on an instance.

Both solve a real problem. Historically an interface could only declare abstract methods, so adding a method to a published interface broke every implementation. Default methods fix that: a new method can arrive with a sensible default body, and existing implementations keep working. That is what made the four functional interfaces in java.util.function possible — Function has a default andThen and compose, and Predicate has default and, or and negate, all built from the single abstract method.

public class Main {
    public static void main(String[] args) {
        Transformer<String> upper = s -> s.toUpperCase();
        Transformer<String> trimmed = Transformer.<String>identity().andThen(s -> s + "!");

        System.out.println("upper    : " + upper.apply(" hello "));
        System.out.println("trimmed  : " + trimmed.apply(" hello "));

        // A static method on the interface.
        System.out.println("version  : " + Transformer.version());
    }
}

@FunctionalInterface
interface Transformer<T> {
    T apply(T input);

    // A default method: a reusable combination built from the SAM.
    default Transformer<T> andThen(Transformer<T> after) {
        return value -> after.apply(this.apply(value));
    }

    // A static method belongs to the interface, not to an instance.
    static String version() {
        return "Transformer v1";
    }

    static <T> Transformer<T> identity() {
        return value -> value;
    }
}

The output shows both mechanisms. The default method builds a composed transformer out of the abstract one, so an implementation gets that composition for free. And the static method is called on the interface, producing a version string with no instance involved.

One design warning to close with. Default methods are powerful precisely because they are inherited silently, so they should stay small and genuinely universal. A default method that grows into a hundred lines of implementation inside an interface is a design smell that no compiler will warn you about, and every implementor inherits it whether they want it or not.