Funktionsschnittstelle in Java

Es wurde erstmals in Java 8 eingeführt. Eine funktionale Schnittstelle kann als Schnittstelle mit einer einzelnen abstrakten Methode definiert werden. Das bedeutet, dass funktionale Schnittstellen in Java nur eine einzige Grundfunktionalität bereitstellen. Eine funktionale Schnittstelle kann jedoch zusätzlich zu einer einzelnen abstrakten Methode statische und Standardmethoden enthalten. java.util.function.Function, java.util.function.Predicate, UnaryOperator, BinaryOperator, Supplier, Consumer sind Beispiele für integrierte Funktionsschnittstellen in Java.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Syntax der funktionalen Schnittstelle

Hier ist eine grundlegende Syntax angegeben:

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

Aus der obigen Syntax können wir erkennen, dass die Schnittstelle mit dem Namen MyFunctionalInterface nur eine einzige nicht implementierte Methode enthält; Deshalb kann es als funktionale Schnittstelle betrachtet werden. Es kann auch statische und Standardmethoden wie die unten gezeigte enthalten:

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();
}

Außerdem kann eine funktionale Schnittstelle mithilfe eines Lambda-Ausdrucks wie dem folgenden implementiert werden:

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

Wir können auch eine Annotation verwenden oder eine Schnittstelle als funktionale Schnittstelle deklarieren. So kann eine funktionale Schnittstelle mithilfe einer Annotation deklariert werden:

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

@FunctionalInterface wurde in Java 8 eingeführt und wird für Fehler auf Compilerebene verwendet, falls eine Schnittstelle gegen Regeln einer funktionalen Schnittstelle verstößt. Durch die Deklaration einer Schnittstelle mithilfe der Annotation @FunctionalInterface wird eine Schnittstelle funktionsfähig. Wenn mehr als eine abstrakte Methode verwendet wird, wird ein Kompilierungsfehler generiert.

Wichtige Punkte zur Funktionsschnittstelle

Hier sind einige wichtige Punkte:

• In einer Funktionsschnittstelle ist nur eine abstrakte Methode zulässig. Wenn die Annotation @FunctionalInterface nicht mit einer Funktionsschnittstelle verwendet wird, können mehr als eine abstrakte Methode deklariert werden. In diesem Fall wird diese Schnittstelle jedoch als nicht funktionsfähig betrachtet.
• Die Verwendung der @FunctionalInterface-Annotation ist optional; Es wird nur zur Überprüfung auf Compilerebene verwendet.
• Eine funktionale Schnittstelle kann eine beliebige Anzahl statischer und Standardmethoden enthalten.
• Das Überschreiben von Methoden der übergeordneten Klasse verstößt nicht gegen die Regeln einer funktionalen Schnittstelle.

Beispiel:

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

Da die obige Schnittstelle eine Methode der übergeordneten Klasse überschreibt und nicht mehrere abstrakte Methoden deklariert, kann sie als funktionale Schnittstelle betrachtet werden.

Beispiele zur Implementierung einer funktionalen Schnittstelle

Jetzt sehen wir Java-Codebeispiele, die die Deklaration und Verwendung der Java-Funktionsschnittstelle zeigen.

Beispiel #1

In diesem Beispiel zeigen wir, wie die integrierte Funktionsschnittstelle java.util.function.function interface verwendet wird. Hier ist die Deklaration der Funktionsschnittstelle.

Schnittstelle:

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

Um die obige Schnittstelle verwenden zu können, müssen wir sie wie folgt in unserer Klasse implementieren.

Code:

import java.util.function.*;
public class FunctionalInterfaceDemo implements Function<Integer, Integer>{
@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);
}
}

Ausgabe:

Beispiel #2

In diesem Beispiel werden wir sehen, wie diese Schnittstellen mithilfe von Lambda-Ausdrücken erstellt werden.

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();
}
}

Ausgabe:

Beispiel #3

In diesem Beispiel sehen wir die Verwendung eines anderen integrierten Schnittstellenkonsumenten, um eine Liste zu iterieren.

Code:

import java.util.function.*;
import java.util.*;
public class FunctionalInterfaceDemo{
public static void main (String args[]){
List<String> list = new ArrayList<String>();
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<String>(){
@Override
public void accept(String item){
System.out.println(item);
}
});
}
}

Ausgabe:

Fazit

Der obige Artikel vermittelt ein klares Verständnis der Funktionsschnittstellen in Java. Der Hauptvorteil der Verwendung von Java 8-Funktionsschnittstellen ist die Unterstützung von Lambda-Ausdrücken, wodurch viel Boilerplate-Code entfernt wird, was wiederum zur Entwicklung von kleinem, effizientem und saubererem Code führt.

Das obige ist der detaillierte Inhalt vonFunktionsschnittstelle in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!