Functional interfaces are new additions in java 8 which permit exactly one abstract method inside them. These interfaces are also called Single Abstract Method interfaces (SAM Interfaces). These can be represented using Lambda expressions, Method reference and constructor references as well. Java 8 introduces an annotation i.e. @FunctionalInterface too, which can be used for compiler level errors when the interface you have annotated violates the contracts of Functional Interface.
Do’s and Don’t’s in functional interfaces
Below is list of things which are allowed and which are not in a functional interface.
A) As discussed above, only one abstract
method is allowed in any functional interface. Second abstract method is not permitted in a functional interface. If we
remove @FunctionInterface annotation then we are allowed to add another
abstract method, but it will make the interface non-functional interface.
B) A functional interface is valid even if the
@FunctionalInterface annotation would be omitted. It is only for informing
the compiler to enforce single abstract method
inside interface.
C) Conceptually, a functional interface has
exactly one abstract method. Since default methods have an
implementation, they are not abstract. Since default methods are not abstract
you’re free to add default methods to your functional interface as many as
you like.
D) If an interface declares an abstract method
overriding one of the public methods of java.lang.Object, that also does not
count toward the interface’s abstract method count since any implementation
of the interface will have an implementation from java.lang.Object or
elsewhere. e.g. Comparator
is a functional interface even though it declared two abstract methods. Why?
Because one of these abstract methods “equals()” which has signature
equal to public method in Object class.
