EDUCBA

EDUCBA

MENUMENU
  • Free Tutorials
  • Free Courses
  • Certification Courses
  • 600+ Courses All in One Bundle
  • Login
Home Software Development Software Development Tutorials Java 8 Tutorial Java 8 Functional Interface
Secondary Sidebar
Java 8 Tutorial
  • Java 8 basic
    • Java 8 forEach
    • Java 8 Documentation
    • Java 8 Method Reference
    • Java 8 List to Map
    • Java 8 Parallel Stream
    • Java 8 Functional Interface
    • Java 8 API
    • Java 8 Lambda
    • Java 8 Comparator
    • Java 8 Group By
    • Java 8 Predicate
    • Java 8 Default Methods
    • Java 8 Thread
    • Java 8 HashMap
    • Java 8 Read File
    • Java 8 OpenJDK
    • Java 8 Stream Filter
    • Java 8 Interface

Java 8 Functional Interface

Definition

The Java 8 functional interface is an interface that contains only one abstract method and any count of default and static methods. These functional interfaces have only one functionality. An Abstract method is a method that doesn’t need implementation while declaring it and is mandatorily overridden by a class that executes the interface. The annotation used to implement the Java 8 functional interface is @FunctionalInterface.

Java 8 functional interface

What is Java 8 Functional Interface?

Java 8 has a new feature that offers users a fundamental programming approach. This feature is the ‘functional interface’, also known as the ‘Single Abstract Method’ interface, that is, the SAM interface. Java 8 includes functional interfaces, Lambda expressions, and method references. The collective impact of the preceding three is that the code is made straightforward, clean, and more readable.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

Key Takeaways

  • Java 8 has introduced the ‘functional interface’ aka Single Abstract Method (SAM) interface.
  • The Java 8 functional interface has only one abstract method along with none or some static methods and default methods.
  • Lambda expressions create an instance of a functional interface.
  • The java.util.function package consists of many inbuilt functions.

Why do we need Java 8 Functional Interface?

Java 8 functional interfaces are instantiated using Lambda expressions. Here, the benefit is that you can avoid the implementation of bulky anonymous classes. The amount of code is decreased to a large extent. The code becomes more clean and readable. The second advantage is that you can leverage the Stream API sequential and parallel operations support. The code is processed in lesser time. The third benefit is that you can use lambda expressions for passing the behavior of a method. In a nutshell, the Java 8 functional interface is needed to decrease code and processing time and augment readability. Before Java 8, if you wanted to implement any functionality, it was mandatory to create a class. This involved considerable boilerplate code. This code is now reduced.

Java 8 Functional Interface

A functional interface is an interface that consists of only one Abstract method. To mark a functional interface, you can use the annotation ‘@FunctionalInterface.’ The addition of this annotation is optional, but it is a good practice to include this annotation. You can prevent the accidental addition of extra methods by including this annotation. If you use this annotation and then include more than one Abstract method, the compiler throws an error.

You can use Lambda expressions to instantiate the Java 8 functional interfaces. Due to this, you can prevent the implementation of bulky anonymous classes. This is the prime advantage of functional interfaces. Developers have rewritten the Java 8 Collections API. They have introduced the new Stream API, which makes use of a large count of functional interfaces. The java.util.function package has a plethora of inbuilt functional interfaces. Some major functional interfaces in Java 8 are Consumer, Function, Supplier, and Predicate. An example of a Java 8 functional interface is java.lang.Runnable, which comprises only one Abstract method run().

Lambda Expression

Lambda expressions create an instance of a functional interface. In the Java object-oriented world, you can visualize functional programming by leveraging Lambda expressions. The foundation of the Java programming language is an object. You cannot use a function if you do not have an object. This is the reason for the Java language to endorse the usage of Lambda expressions with functional interfaces only. Functional interfaces have only one Abstract method, due to which there is no confusion while using the Lambda expression in the method. The syntax of Lambda expressions is the following.

Syntax:

(argument)              (body)

Developers have used a Lambda expression to write the anonymous Runnable functional interface, which is the following.

Code:

Runnable r1 = () -> System.out.printIn("My Runnable");

In the preceding code, the functional interface is Runnable. To create its instance, you can use a Lambda expression. The run() method does not accept any argument. So, the preceding Lambda expression lacks an argument. Because the method body has only one statement, you need not include curly brackets ({}). You can use these curly brackets if there is more than one statement in the method body.

Method

When you want to refer to a method but do not want to invoke it, you can use the method reference. On similar lines, when you want to refer to a constructor but do not want to create a new instance of the named array type or class, you can use the constructor reference.

A functional interface can have an abstract method, static methods, and default methods. You can use default methods directly in a class implementing the functional interface. You can also override and redefine the default methods. You can call static methods using the functional interface name preceding the method name. You cannot override static methods using the classes that implement the functional interface.

Primitive Type

The Primitive Function functional interface is almost similar to the Function functional interface. The difference between these two is the following. The Function functional interface accepts an argument of all data types and returns a value of all data types. But, the Primitive Function functional interface accepts only one argument of a primitive data type, such as int, double, or long. The processing speed of the Primitive Function functional interface is more than the Function functional interface. The primitive-type is converted to the wrapper-type and vice versa in the case of auto-boxing and auto-unboxing. To avoid these conversions, the following Primitive Function functional interfaces are introduced: IntFunction, LongFunction, and DoubleFunction.

Examples of Java 8 Functional Interface

In the following example, a functional interface ‘speakout’ is created. It has an Abstract method ‘line.’ The class ‘FunctionalInterfaceExample’ executes the interface ‘speakout.’ In this class, the method line accepts a string argument and prints this argument. In the main() function, a new object of the class is created. This calls the ‘line’ method.

Code:

@FunctionalInterface
interface speakout{
	void line(String audio);
}
public class FunctionalInterfaceExample implements speakout{
	public void line(String audio){
		System.out.println(audio);
	}
	public static void main(String[] args) {
		FunctionalInterfaceExample g1 = new FunctionalInterfaceExample();
		g1.line("Hello there");
	}
}

Output:

Java 8 Functional Interface - Hello there

Conclusion

The Java 8 functional interface minimizes the amount of code and augments readability. It consists of only one Abstract method along with none or some Static methods and Default methods. One Abstract method has only one functionality. Java 8 has several inbuilt functional interfaces. You can create instances of a functional interface by using Lambda Expressions.

Recommended Articles

This article helps you to learn about the Java 8 Functional Interface. To know more about the same topic, you can refer to these articles.

  1. Text File in Java
  2. Java 8 reduce
  3. Java 8 ExecutorService
  4. Java 8 Documentation
Primary Sidebar
Footer
About Us
  • Blog
  • Who is EDUCBA?
  • Sign Up
  • Live Classes
  • Corporate Training
  • Certificate from Top Institutions
  • Contact Us
  • Verifiable Certificate
  • Reviews
  • Terms and Conditions
  • Privacy Policy
  •  
Apps
  • iPhone & iPad
  • Android
Resources
  • Free Courses
  • Java Tutorials
  • Python Tutorials
  • All Tutorials
Certification Courses
  • All Courses
  • Software Development Course - All in One Bundle
  • Become a Python Developer
  • Java Course
  • Become a Selenium Automation Tester
  • Become an IoT Developer
  • ASP.NET Course
  • VB.NET Course
  • PHP Course

ISO 10004:2018 & ISO 9001:2015 Certified

© 2023 - EDUCBA. ALL RIGHTS RESERVED. THE CERTIFICATION NAMES ARE THE TRADEMARKS OF THEIR RESPECTIVE OWNERS.

EDUCBA

*Please provide your correct email id. Login details for this Free course will be emailed to you

Let’s Get Started

By signing up, you agree to our Terms of Use and Privacy Policy.

EDUCBA

*Please provide your correct email id. Login details for this Free course will be emailed to you
EDUCBA

*Please provide your correct email id. Login details for this Free course will be emailed to you
EDUCBA Login

Forgot Password?

By signing up, you agree to our Terms of Use and Privacy Policy.

This website or its third-party tools use cookies, which are necessary to its functioning and required to achieve the purposes illustrated in the cookie policy. By closing this banner, scrolling this page, clicking a link or continuing to browse otherwise, you agree to our Privacy Policy

Loading . . .
Quiz
Question:

Answer:

Quiz Result
Total QuestionsCorrect AnswersWrong AnswersPercentage

Explore 1000+ varieties of Mock tests View more