Functional Interface in Java

It was first introduced in java 8. A functional interface can be defined as an interface with a single abstract method. This means functional interfaces in java provide only a single basic functionality. However, a functional interface can contain static and default methods, in addition to a single abstract method. java.util.function.Function, java.util.function.Predicate, UnaryOperator, BinaryOperator, Supplier, Consumer are examples of built-in functional interfaces in java.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

Syntax of Functional Interface

Here is a basic syntax is given below:

public interface MyFunctionalInterface(){ // abstract method public void functionalMethod(); }

From the above syntax, we can see that the interface named MyFunctionalInterface contains only a single unimplemented method; that’s why it can be considered as a functional interface.It can also contain static and default methods like the one shown below:

public interface MyFunctionalInterface(){ public default void defaultMethod(){ // default method logic goes here } public static void staticMethod(){ // static method logic goes here } // abstract method public void functionalMethod(); }

Also, a functional interface can be implemented using Lambda expression like the following:

MyFunctionalInterface functionalInterface = () ->{ // basic functionality logic goes here }

We can also use an annotation or declaring an interface as a functional interface. Here is how a functional interface can be declared using an annotation:

MyFunctionalInterface functionalInterface = () ->{ // basic functionality logic goes here }

@FunctionalInterface was introduced in java 8 and is used for compiler level error in case an interface breaks rules of a functional interface. Declaring an interface using @FunctionalInterface annotation makes an interface functional, and if more than one abstract method is used, it will generate a compilation error.

Important Points Regarding Functional Interface

Here are some important points :

• Only one abstract method is allowed in a function interface. If @FunctionalInterface annotation is not used with a function interface, then more than one abstract method can be declared, but in that case, that interface will be regarded as non-functional.
• Use of @FunctionalInterface annotation is optional; it is only used for compiler level checking.
• A Functional interface can contain any number of static and default methods.
• Overriding methods from the parent class do not break the rules of a functional interface.

Example:

@FunctionalInterface public interface MyFunctionalInterface(){ // abstract method public void functionalMethod(); @Override public boolean equals(Object object); //method overridden from parent class }

Since the above interface overrides a method from the parent class and does not declare multiple abstract methods, it can be considered as a functional interface.

Examples to Implement Functional Interface

Now we will see java code examples showing declaration and usage of the java functional interface.

Example #1

In this example, we will show how built-in function interface java.util.function.function interface is used. Here is the declaration of the Function interface.

Interface:

package java.util.function; public interface Function{ public  apply(T inputparams); }

In order to use the above interface, we need to implement it in our class like the following.

Code:

import java.util.function.*; public class FunctionalInterfaceDemo implements Function{ @Override public Integer apply (Integer n){ return n*n; } public static void main (String args[]){ FunctionalInterfaceDemo demo = new FunctionalInterfaceDemo (); Integer sqroot= demo.apply(12); System.out.println("Square root of 12 is " + sqroot); } }

Output:

Example #2

In this example, we will see how these interfaces are created using lambda expressions.

Code:

public class FunctionalInterfaceDemo{ public static void main (String args[]){ // creating functional Interface instance Runnable r = () -> {System.out.println ("Executing Thread........");}; new Thread(r).start(); } }

Output:

Example #3

In this example, we will see the use of another built-in interface consumer to iterate a List.

Code:

import java.util.function.*; import java.util.*; public class FunctionalInterfaceDemo{ public static void main (String args[]){ List list = new ArrayList(); list.add("One"); list.add("Two"); list.add("Three"); list.add("Four"); list.add("Five"); list.add("Six"); // Iterate arraylist using consumer list.forEach(new Consumer(){ @Override public void accept(String item){ System.out.println(item); } }); } }

Output:

Conclusion

The above article gives a clear understanding of functional interfaces in java. The major advantage of using java 8 functional interfaces is support for lambda expressions which removes a lot of boilerplate code, which in turn results in the development of small, efficient, and cleaner code.

以上是Functional Interface in Java的詳細內容。更多資訊請關注PHP中文網其他相關文章！