Java @FunctionalInterface Annotation

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

✅ Some premium posts are free to read — no account needed. Follow me on Medium to stay updated and support my writing.

🎓 Top 10 Udemy Courses (Huge Discount): Explore My Udemy Courses — Learn through real-time, project-based development.

▶️ Subscribe to My YouTube Channel (172K+ subscribers): Java Guides on YouTube

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.

Read more at http://www.javaguides.net/2018/07/java-8-functional-interfaces.html

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:

Read more about Predefined-Functional Interfaces at http://www.javaguides.net/2018/07/java-8-functional-interfaces.html

References

http://www.javaguides.net/2018/07/java-8-functional-interfaces.html

https://docs.oracle.com/javase/8/docs/api/java/lang/FunctionalInterface.html