Java 8 : Functional Interface Example
To Support lambda expressions in Java 8, they introduced Functional Interfaces.
An interface which has Single Abstract Method can be called as Functional Interface.
Runnable, Comparator,Cloneable are some of the examples for Functional Interface. We can implement these Functional Interfaces by using Lambda expression.
For example:
Thread t =new Thread(new Runnable(){ public void run(){ System.out.println("Runnable implemented by using Lambda Expression"); } });
This is the old way of creating a Thread.
As Runnable is having Single Abstract Method, we can consider this as a Functional Interface and we can use Lambda expression like below.
Thread t = new Thread(()->{ System.out.println("Runnable implemented by using Lambda Expression"); });
Here instead of passing Runnable object we just passed lambda expression.
Declaring our own Functional Interfaces:
We can declare our own Functional Interface by defining Single Abstract Method in interface.
public interface FunctionalInterfaceTest{ void display(); } //Test class to implement above interface public class FunctionInterfaceTestImpl { public static void main(String[] args){ //Old way using anonymous inner class FunctionalInterfaceTest fit = new FunctionalInterfaceTest(){ public void display(){ System.out.println("Display from old way"); }}; fit.display();//outputs: Display from old way //Using lambda expression FunctionalInterfaceTest newWay = () -> {System.out.println("Display from new Lambda Expression");} newWay.display();//outputs : Display from new Lambda Expression } }
We can annotate with @FunctionalInterface annotation, to tell compile time errors. It is optional
for ex:
@FunctionalInterface public interface FunctionalInterfaceTest{ void display(); void anotherDisplay();//shows an error, FunctionalInterface should have only one abstarct method. }
Default Method:
Functional interface can not have more than one abstract method but it can have more than one default methods.
Default methods are introduced in Java 8, to add new methods to interface with out disturbing the implemented classes.
interface DefaultInterfaceTest{ void show(); default void display(){ System.out.println("Default method from interface can have body..!"); } } public class DefaultInterfaceTestImpl implements DefaultInterfaceTest{ public void show(){ System.out.println("show method"); } //we dont need to provide any implementation to default method. public static void main(String[] args){ DefaultInterfaceTest obj = new DefaultInterfaceTestImpl(); obj.show();//out puts: show method obj.display();//outputs : Default method from interface can have body..! } }
Main use of default method is with out forcing the implemented class , we can add a method to an interface.
Multiple Inheritance:
If the same default method is there in two interfaces and one class is implementing that interface, then it will throw an error.
//Normal interface with show method interface Test{ default void show(){ System.out.println("show from Test"); } } //Another interface with same show method interface AnotherTest{ default void show(){ System.out.println("show from Test"); } } //Main class to implement above two interfaces class Main implements Test, AnotherTest{ //here is an ambiguity which show method has to inherit here }
This class wont compile because there is an ambiguity between Test, AnotherTest interfaces show() method, to resolve this we need to override show() method to Main Class.
class Main implements Test, AnotherTest{ void show(){ System.out.println("Main show method"); } }
then what is the use of Abstract class…? I mean Abstract class is also having the same features and behaviors.. I just want to know what exactly the difference between Abstract class and Interface with default method…?
Default methods are for backward compatibility. In Java 8 we have forEach method in List interface. We have to provide implementation to forEach method in all the classes which implement List interface, this is unnecessary. And difference between abstract class and java 8 interface is java 8 interface wont inherit the Object class methods, but abstract class will have all the object class methods.
“java 8 interface is java 8 interface wont inherit the Object class methods” , No interface inherits any class .
And more over abstract vs interface in java 8,
In abstract class you can create local variable but not in interface (not even in older construct).
In Interface you can not declare object class’s method or overrides but you can overrides in Abstract class.
very nice.
why we use abstract before adapter class in interface
Nice post
Thanks
Dear Ramesh,
Please note that in you FunctionInterfaceTestImpl class in the line below there is a statement missing. Please add a semicolon at the end of the statement.
Corrected Satements:
FunctionalInterfaceTest newWay = () -> {System.out.println(“Display from new Lambda Expression”);};
newWay.display();//outputs : Display from new Lambda Expression
}
Thank you for your kind efforts to help the java learner.
isn’t Cloneable a Marker Interface?? then how it can be a SAM interface??
You explained very nice about java 8 new feature “Functional Interfaces”.
thanks for this great post.