Functional Interfaces in Java

A functional interface in Java is an interface that has exactly one abstract method. It is used as the type of a lambda expression or method reference: the lambda provides the body of that one method. Examples you already know are Runnable (run), Comparator (compare) and Comparable (compareTo). A functional interface may also have any number of default and static methods. In this lesson, you will learn the rules of functional interfaces, the @FunctionalInterface annotation, and how to write your own.

Syntax

@FunctionalInterface
interface Validator {
    boolean isValid(String input);   // the single abstract method
}

Rules of a Functional Interface

• Exactly one abstract method. This method is sometimes called the SAM (single abstract method).
• Default and static methods are allowed in any number, because they already have bodies.
• Methods of Object (such as equals and toString) declared in the interface don't count, because every class already has them.
• @FunctionalInterface is optional, but recommended: the compiler then reports an error if someone adds a second abstract method.

Example: Your Own Functional Interface

Let's see an example of a validator implemented with lambdas.

public class Validators {
    @FunctionalInterface
    interface Validator {
        boolean isValid(String input);
 
        default Validator and(Validator other) {
            return s -> isValid(s) && other.isValid(s);
        }
    }
 
    public static void main(String[] args) {
        Validator notEmpty = s -> !s.isEmpty();
        Validator shortName = s -> s.length() <= 8;
        Validator both = notEmpty.and(shortName);
 
        for (String name : new String[] {"Navika", "", "Anamaneni"}) {
            System.out.println("\"" + name + "\" valid? " + both.isValid(name));
        }
    }
}

"Navika" valid? true
"" valid? false
"Anamaneni" valid? false

Explanation: Validator has one abstract method, isValid, so lambdas can implement it. The default method and combines two validators into a new one. An empty name fails notEmpty, and "Anamaneni" has 9 letters, so it fails shortName.

What @FunctionalInterface Checks

If an interface marked @FunctionalInterface gets a second abstract method, the compiler stops you:

@FunctionalInterface
interface Broken {
    void first();
    void second();
}

Broken.java:1: error: Unexpected @FunctionalInterface annotation
@FunctionalInterface
^
  Broken is not a functional interface
    multiple non-overriding abstract methods found in interface Broken
1 error

Explanation: Broken has two abstract methods, so a lambda couldn't know which one to implement. The annotation turns this mistake into a compile error at the interface itself.

Common Functional Interfaces in the JDK

Common Mistakes

Adding a second abstract method to an interface that lambdas use. Every lambda for it stops compiling; @FunctionalInterface catches this early.

Thinking equals counts as an abstract method. Methods inherited from Object don't count.

Thinking the annotation is required. Any interface with one abstract method works with lambdas.

Interview Corner

Practice

1. Easy: Write a functional interface Discount with double apply(double price) and lambdas for 10% off and a flat 50 off.
2. Harder: Add a default method then(Discount next) that applies this discount and then the next one, and test it.

Key Takeaways