Pfthb

Not at all. Lambda expressions are the one and only point of that annotation.

The documentation makes indeed a difference between the purpose

An informative annotation type used to indicate that an interface type declaration is intended to be a functional interface as defined by the Java Language Specification.

and the use case

Note that instances of functional interfaces can be created with lambda expressions, method references, or constructor references.

whose wording does not preclude other use cases in general. Since the primary purpose is to indicate a functional interface, your actual question boils down to “Are there other use cases for functional interfaces other than lambda expressions and method/constructor references?”

Since functional interface is a Java language construct defined by the Java Language Specification, only that specification can answer that question:

JLS §9.8. Functional Interfaces:

…

In addition to the usual process of creating an interface instance by declaring and instantiating a class (§15.9), instances of functional interfaces can be created with method reference expressions and lambda expressions (§15.13, §15.27).

So the Java Language Specification doesn’t say otherwise, the only use case mentioned in that section is that of creating interface instances with method reference expressions and lambda expressions. (This includes constructor references as they are noted as one form of method reference expression in the specification).

So in one sentence, no, there is no other use case for it in Java 8.

As others have said, a functional interface is an interface which exposes one method. It may have more than one method, but all of the others must have a default implementation. The reason it's called a "functional interface" is because it effectively acts as a function. Since you can pass interfaces as parameters, it means that functions are now "first-class citizens" like in functional programming languages. This has many benefits, and you'll see them quite a lot when using the Stream API. Of course, lambda expressions are the main obvious use for them.

A lambda expression can be assigned to a functional interface type, but so can method references, and anonymous classes.

One nice thing about the specific functional interfaces in java.util.function is that they can be composed to create new functions (like Function.andThen and Function.compose, Predicate.and, etc.) due to the handy default methods they contain.

An interface with only one abstract method is called Functional Interface.
It is not mandatory to use @FunctionalInterface, but it’s best practice to use it with functional interfaces to avoid addition of extra methods accidentally. If the interface is annotated with @FunctionalInterface annotation and we try to have more than one abstract method, it throws compiler error.

package com.akhi;
 @FunctionalInterface
 public interface FucnctionalDemo 

 void letsDoSomething();
 //void letsGo(); //invalid because another abstract method does not allow
 public String toString(); // valid because toString from Object 
 public boolean equals(Object o); //valid

 public static int sum(int a,int b) // valid because method static
 
 return a+b;
 
 public default int sub(int a,int b) //valid because method default
 
 return a-b;
 
 

@FunctionalInterface is a new annotation are released with Java 8 and provide target types for lambda expressions and it used on compilation time checking of your code.

When you want to use it :

1- Your interface must not have more than one abstract methods, otherwise compilation error will be given.

1- Your interface Should be pure, which means functional interface is intended to be implemented by stateless classes, exmple of pure is Comparator interface because its not depend on the implementers state, in this case No compilation error will be given, but in many cases you will not be able to use lambda with this kind of interfaces

The java.util.function package contains various general purpose functional interfaces such as Predicate, Consumer, Function, and Supplier.

Also please note that you can use lambdas without this annotation.

You can use lambda in Java 8

 public static void main(String args) 
 tentimes(inputPrm -> System.out.println(inputPrm));
 //tentimes(System.out::println); // You can also replace lambda with static method reference
 

 public static void tentimes(Consumer myFunction)
 for(int i = 0; i < 10; i++)
 myFunction.accept("hello");
 

For further info about Java Lambdas and FunctionalInterfaces

Beside other answers, I think the main reason to "why using Functional Interface other than directly with lambda expressions" can be related to nature of Java language which is Object Oriented.

The main attributes of Lambda expressions are: 1. They can be passed around 2. and they can executed in future in specific time (several times). Now to support this feature in languages, some other languages deal simply with this matter.

For instance in Java Script, a function (Anonymous function, or Function literals) can be addressed as a object. So, you can create them simply and also they can be assigned to a variable and so forth. For example:

var myFunction = function (...) 
 ...;

alert(myFunction(...));

or via ES6, you can use an arrow function.

const myFunction = ... => ...

Up to now, Java language designers have not accepted to handle mentioned features via these manner (functional programming techniques). They believe that Java language is Object Oriented and therefore they should solve this problem via Object Oriented techniques. They don't want to miss simplicity and consistency of Java language.

Therefore, they use interfaces, as when an object of an interface with just one method (I mean functional interface) is need you can replace it with a lambda expression. Such as:

ActionListener listener = event -> ...;

Functional Interface:
- Introduces from Java 8
- Interface that contains a "single abstract" method.
Example 1:

 interface CalcArea // --functional interface
 double calcArea(double rad);
 

 Example 2: 
 interface CalcGeometry // --functional interface
 double calcArea(double rad);
 default double calcPeri(double rad) 
 return 0.0;
 
 

 Example 3: 
 interface CalcGeometry // -- not functional interface
 double calcArea(double rad);
 double calcPeri(double rad);
 

- Java8 annotation -- @FunctionalInterface
 - Annotation check that interface contains only one abstract method. If not, raise error.
 - Even though @FunctionalInterface missing, it is still functional interface (if having single abstract method). The annotation helps avoid mistakes.
 - Functional interface may have additional static & default methods.
 - e.g. Iterable<>, Comparable<>, Comparator<>.


Applications of Functional Interface
1. Method references
2. Lambda Expression and
3. Constructor references

To learn functional interface , learn first default methods in interface, and after learning functional interface it will be easy to you to understand method reference and lambda expression