Better applicability to make an interface functional

Question

Starting from java 8, for an interface to become functional, it needs to have only one right method ? However we have the @Functionface annotation, which explicitly defines that this interface is functional.

But what is the main difference in using or not this annotation, if with only one method it already becomes functional ?

    @FunctionalInterface
public interface FuncionalInterface <T>{
    boolean valida(T t);
}

public interface FuncionalInterface <T>{
    boolean valida(T t);
}

When printing the result is the same either with the annotation or without, see in main:

public static void main(String[] args) {
    FuncionalInterface<String> funcionalInterface = valor -> valor.matches("[0-9]{5}-[0-9]{3}");
    System.out.println(funcionalInterface.valida("45680-000"));

}

Answer 1

As described in documentation, this annotation serves primarily to state your intention to use it as a functional interface.

One of the aspects involves leaving this intention explicit and documented in the code, which is good practice.

Documentation that is part of the code allows for a number of facilities that do not necessarily affect system execution, but can serve as a hint to your IDE correctly completing the code, for the compiler to perform some additional operation or verification or even for the next programmer who will use its classes and will not read the system manual.

In this case, as also cited in the documentation, this annotation requires the compiler to issue errors in the following cases:

• The type in question is not an interface
• The interface does not meet the criteria of a functional interface

So the main difference is that if you add one more method to the two interfaces you put in the question, one will compile and the other will not.

Think of the case of an interface that is used by another system and not just by its own code. Adding one more method may not do any harm to your code, but it may break third-party code.

So, in a practical way, the least that annotation does is remind you every time you stop at the class that it’s not a good idea to put one more method there.

Answer 2

You don’t need to do anything special for an interface to be considered functional. The compiler already identifies this type of interface by its structure.

The annotation @FunctionalInterface servepara that the fact of it being a functional interface is not by the mere coincidence of having a single one method. To do this we use the annotation @FuncionalInterface:

Mark your interface with the annotation and trigger any other method in it, so you will see that the compiler has an error.