Java 8 Functional Interfaces Introduction Example

YatinJuly 15th, 2019Last Updated: July 15th, 2019

0 103 4 minutes read

Hello readers! In this tutorial, we will learn the amazing feature of Java 8 Functional Interfaces.

1. Introduction

To achieve the benefits of functional programming in Java, JDK developers introduced Functional Interfaces/Single Abstract Method (SAM) Interfaces in Java 8 programming.

A functional interface is an interface that has only one abstract method
A functional interface can have multiple default and static methods
@FunctionalInterface annotation ensures that the interface will be treated as a functional interface. This annotation throws a compile-time error if the primary condition for SAM interfaces is not met
Callable, Runnable, ActionListener, Comparable, Consumer, Supplier, Predicate, etc. are some examples of functional interfaces introduced in Java 8
Syntax:
1
2
3
4
5
@FunctionalInterface
public interface Interface1 {
public abstract void method1();
default void method2() { System.out.println("Hello World!"); }
}

A functional interface can override the methods of java.lang.Object class

@FunctionalInterface
public interface Interface2 {
    public abstract void method2();
    // java.lang.Object class methods.
    boolean equals(Object o);
    string toString();
    int hashCode();
}

1.1 Inheritance & Functional Interfaces

If a normal interface extends a functional interface and the child interface does not contain any method, then child interface is also a Functional Interface

@FunctionalInterface
interface Interface1 {
    public void method1();
}
 
@FunctionalInterface
interface Interface2 extends Interface1 {   // Interface2 is also a child interface.
     
}

In the child functional interface, we can define the exact same method as in the parent interface

@FunctionalInterface
interface Interface1 {
    public void method1();
}
 
@FunctionalInterface
interface Interface2 extends Interface1 {
    public void method1();      // No compile-time error as we have defined the exact same method as in parent interface.
}

If the child interface is a functional interface, we can’t define any new abstract methods. If the former is true, it will result in a compile-time error. However, we can define multiple default and static methods

@FunctionalInterface
interface Interface1 {
    public void method1();
}
 
@FunctionalInterface
interface Interface2 extends Interface1 {
    public void method1();
     
    default void method2() {
        System.out.println("method2()");
    }
     
    static void method3() {
        System.out.println("method3()");
    }
}

If the child interface is not a functional interface, we can define any number of abstract, default, and static methods

1.2 Advantages of Functional Interfaces

Provides compile-time code checking
Helps in lambda expressions instantiation and avoiding anonymous classes implementation

To start with this tutorial, we are hoping that users at present have their preferred IDE and JDK 1.8 installed on their machines. For easy usage, I am using Eclipse IDE.

2. Java 8 Functional Interfaces Introduction Example

Firstly, let us review the project structure that has an interface and class to demonstrate a functional interface in Java 8.

Java 8 Functional Interfaces - Project Structure — Fig. 1: Project Structure

2.1 Project Creation

This section will show how to create a Java-based Maven project with Eclipse. In Eclipse IDE, go to File -> New -> Maven Project.

Java 8 Functional Interfaces - Maven Project — Fig. 2: Create a Maven Project

In the New Maven Project window, it will ask you to select a project location. By default, ‘Use default workspace location’ will be selected. Select the ‘Create a simple project (skip archetype selection)’ check-box and just click on next to proceed.

Java 8 Functional Interfaces - Project Details — Fig. 3: Project Details

It will ask you to ‘Enter the group and the artifact id for the project’. We will input the details as shown in the below image. The version number will be by default: 0.0.1-SNAPSHOT.

Java 8 Functional Interfaces - Archetype Parameters — Fig. 4: Archetype Parameters

Click on Finish and the creation of a maven project is completed. If you observe, it has downloaded the maven dependencies and a pom.xml file will be created.

3. Application Building

To create a new class, right click on the src/main/java folder, New -> Class. Fill in the details about the package and class name as shown in Fig. 5 and click finish.

Java 8 Functional Interfaces - Creating a Class — Fig. 5: Creating a Class

3.1 Functional Interface in Play

Let us add some code to the FunctionalInterface.java class.

FunctionalInterface.java

package jcg.functionalinterface.example;
 
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
 
interface MyRectangle {
    int calculateVolume(int length, int height, int width);
}
 
public class FunctionalInterface {
 
    static List countries = Arrays.asList("America", "India", "Russia", "China", "Japan", "Indonesia");
 
    public static void main(String[] args) {
 
        // Example #1 - Implementing user-defined functional interface using lambda expression.
        MyRectangle rectangle = (int length, int height, int width) -> length * height * width;
        System.out.println(rectangle.calculateVolume(5, 5, 5));
 
        // Example #2 - Runnable functional interface using old implementation (i.e. anonymous class).
        Runnable runnableUsingAnonymousClass = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World from Anonymous Class!");
            }
        };
        Thread myThread1 = new Thread(runnableUsingAnonymousClass);
        myThread1.start();
 
        // Example #3 - Runnable functional interface using lambda expression.
        Runnable runnableUsingLambda = () -> { 
            System.out.println("Hello World from Lambda Expression!"); 
        };
        Thread myThread2 = new Thread(runnableUsingLambda);
        myThread2.start();
 
        // Example #4 - Predicate functional interface.
        Predicate predicate = (name) -> name.startsWith("I");
        for(String name : countries) {
            if(predicate.test(name))
                System.out.println(name);
        }
    }
}

4. Run the Application

Right click on the FunctionalInterface.java class, Run As -> Java Application. The class will be executed and the output will be printed in the ide console.

Output

125
 
Hello World from Anonymous Class!
 
Hello World from Lambda Expression!
 
India
Indonesia

That is all for this tutorial and I hope the article served you whatever you were looking for. Happy Learning and do not forget to share!

5. Summary

In this tutorial, we had an in-depth look at Functional Interfaces in Java 8. Developers can download the sample application as an Eclipse project in the Downloads section.

6. Download the Eclipse Project

This was an example of Java 8 Functional Interfaces.

Download
You can download the full source code of this example here: Java 8 Functional Interfaces Introduction Example

Java 8 Functional Interfaces Introduction Example

1. Introduction

1.1 Inheritance & Functional Interfaces

1.2 Advantages of Functional Interfaces

2. Java 8 Functional Interfaces Introduction Example

2.1 Project Creation

3. Application Building

3.1 Functional Interface in Play

4. Run the Application

Thank you!

5. Summary

6. Download the Eclipse Project

Thank you!

Yatin

Thank you!

1. Introduction

1.1 Inheritance & Functional Interfaces

1.2 Advantages of Functional Interfaces

2. Java 8 Functional Interfaces Introduction Example

2.1 Project Creation

3. Application Building

3.1 Functional Interface in Play

4. Run the Application

Thank you!

5. Summary

6. Download the Eclipse Project

Thank you!

Related Articles

Thank you!