In this quick article, we will discuss the usage of Java 8 introduced @FunctionalInterface interface.

The @FunctionalInterface annotation indicates that an interface is a functional interface and contains exactly one abstract method.

What is a functional interface?

An Interface that contains exactly one abstract method is known as a functional interface.
A functional interface can have any number of default, static methods but can contain only one abstract method. It can also declare methods of the object class.
Functional Interface is also known as Single Abstract Method Interfaces or SAM Interfaces. It is a new feature in Java 8, which helps to achieve a functional programming approach.
A functional interface can extend another interface only when it does not have any abstract method.

Java @FunctionalInterface Annotation

We can create a custom functional interface using @FunctionalInterface Annotation. Note that instances of functional interfaces can be created with lambda expressions, method references, or constructor references.

If a type is annotated with this annotation type, compilers are required to generate an error message unless:

The type is an interface type and not an annotation type, enum, or class.
The annotated type satisfies the requirements of a functional interface.

Java @FunctionalInterface Annotation Example

Let's demonstrates the usage of @FunctionalInterface annotation with examples. Let's create Sayable interface annotated with @FunctionalInterface annotation.

@FunctionalInterface  
interface Sayable{  
    void say(String msg);   // abstract method   
}

Let's demonstrate a custom functional interface via the main() method.

public class FunctionalInterfacesExample {

    public static void main(String[] args) {

        Sayable sayable = (msg) - > {
            System.out.println(msg);
        };
        sayable.say("Say something ..");
    }
}

Java 8 Predefined-Functional Interfaces

Java 8 provides predefined functional interfaces to deal with functional programming by using lambda and method references.

So Java 8 predefined functional interfaces internally use @FunctionalInterface annotation. Let's look at the internal implementation of the Predicate functional interface: