Functional Interface In Java 8 with Examples - @FunctionalInterface

What is Functional Interface in Java 8? | What is @FunctionalInterface In Java

In Java 8 Functional Interface concept introduced. I will explain what is functional interface and why we use?

So lets start..

What is Functional Interface?

 

functional Interface is Interface that only have one Abstract method. For Qualify functional Interface in java, class only have one Abstract Method.

 

Any Interface is called Functional Interface if it contains only one Abstract method in it.

 

functional interfaces are called SAM (Single Abstract Method) since they have only single abstract method and can have any default and static method. 

One of the major benefits of functional interface is we can use lambda expressions to instantiate them.

Learn about Lambda expression first so you have clear understanding about it.

Lambda expression and its use cases

Following Code of Functional Interface.

@FunctionalInterface

public interface FunctionalInterface {

public static void main(String args[]) {

System.out.println("Main Method");

}

public void abstractMethod();

}

In above code @FunctionalInterface annotation used that is specify that it is Functional Interface.

@FunactionalInterface is Optional but if you use then you must have one Abstract method in your Interface otherwise it gives Error ("Invalid '@FunctionalInterface' annotation; FunctionalInterface is not a functional interface").

If you add another abstract Method in FunctionalInterface then it also cause Error. Checkout following two images for better understanding.

 

image 1

image 2

You can see in second image, i added another abstract method abstractMethodTwo and it gives error. When you compile second image code it will give following error.

FunctionalInterfaceDemo.java:4: error: Unexpected @FunctionalInterface annotation
        @FunctionalInterface
        ^
  FunctionalInterfaceDemo is not a functional interface
    multiple non-overriding abstract methods found in interface FunctionalInterfaceDemo
1 error

So why we use Functional Interface in java? How they are useful in our code? lets see...

Why use Functional Interface?

Functional Interface are used to create anonymous function using lambda expression.

So, Functional Interface is use lambda expression to provide implement interface without writing boiler-plate code.

 

Some functional interfaces :-

• Predicate 
• Consumer 
• Supplier
• Function
• Runnable
• Comparable
  

Example 1 : Functional Interface without Lambda expression

FunctionalInterface.java

@FunctionalInterface
public interface FunctionalInterface {
	public void abstractMethod();
}

InterfaceImplementClass.java

public class InterfaceImplementClass implements FunctionalInterface{

	public void abstractMethod() {
		System.out.println("Implementation of Functional Interface Method without 
                         lambda expression");
	}

	public static void main(String[] args) {
		InterfaceImplementClass object = new InterfaceImplementClass();
		object.abstractMethod();
	}
}

Output :-
Implementation of Functional Interface Method without lambda expression

Example 2 : Functional Interface with lambda expression

InterfaceImplementClass.java

@FunctionalInterface
public interface FunctionalInterface {
    
    // Abstract Method	
    public void abstractMethod();
	
	public static void main(String args[]) {
            
                // Functional Interface implementation with lambda expression
		FunctionalInterface myInterface = () -> {
			System.out.println("Functional Interface 
                                with lambda expression.");
		};
		
		myInterface.abstractMethod();
	}
}

Output :-
Functional Interface with lambda expression.

We seen how we can use @FunctionalInterface with and without lambda. Now in next demo we will see how to implement FunctionalInterface for two arguments.

Example 3 : Functional Interface with two arguments

@FunctionalInterface
public interface FunctionalInterfaceDemo {

    public void addition(int a, int b);
    
}
 
public class Implementation {

    public static void main(String[] args) {
        
        FunctionalInterfaceDemo obj = (a, b) -> System.out.println("Addition is : " +(a+b));
        obj.addition(10, 10);
    }

}

Output :
Addition is : 20
 

Advantage of Functional Interface

The advantage of making these functional interfaces is that we do not need to create a new class just to implement functional interface, we can provide implementations for the abstract method within these interfaces via lambda expression.

 

Static and Default method in Functional Interface

Example 4 : Static and Default method in Functional Interface

@FunctionalInterface
public interface FunctionalInterfaceDemo {

    public int square(int n);
    
    default void defaultMethod() {
        System.out.println("Default method in Functional Interface");
    }
    
    static void staticMethod() {
        System.out.println("Static method in Functional Interface");
    }
    
}
 
public class Implementation {

    public static void main(String[] args) {
        
        // Implementing square method
        FunctionalInterfaceDemo f = n -> n*n;
        System.out.println("Square of 4 is : " +f.square(4));
        
        // Calling Default method
        f.defaultMethod();
        
        // Calling Static method
        FunctionalInterfaceDemo.staticMethod();
        
    }

}

Output :
Square of 4 is : 16
Default method in Functional Interface
Static method in Functional Interface

@FunctionalInterface vs Inheritance

Lets see some key point use FunctionalInterface with Inheritance

 

Demo 1 :

@FunctionalInterface
public interface InterfaceOne {

    public int methodOne();
    
}

@FunctionalInterface
public interface InterfaceTwo extends InterfaceOne {
    
}

Valid. 

Because InterfaceTwo extends InterfaceOne and that contains one abstract method so, by default available in InterfaceTwo.

 

------------------------------------

 

Demo 2 :

@FunctionalInterface
public interface InterfaceOne {

    public void methodOne();
    
}

@FunctionalInterface
public interface InterfaceTwo extends InterfaceOne {
     
    public void methodOne();
  
}

Valid.
Because InterfaceOne and InterfaceTwo contains same method.

------------------------------------

Demo 3 :

@FunctionalInterface
public interface InterfaceOne {

    public void methodOne();
    
}

@FunctionalInterface
public interface InterfaceTwo extends InterfaceOne {
     
    public void methodTwo();
  
}

Invalid.

Because InterfaceTwo extends InterfaceOne so by default in InterfaceTwo we have one abstract method. And In InterfaceTwo there is another abstract method methodTwo. so it violates @FunctionalInterface rule.  

 

Happy Coding.

Learn More about Functional Interface.