logo

Functionele Java-interfaces

Een functionele interface in Java is een interface die slechts één abstracte methode bevat. Functionele interfaces kunnen meerdere standaard- of statische methoden hebben, maar slechts één abstracte methode.

Vanaf Java 8 kunnen lambda-expressies en methodereferenties worden gebruikt om de instantie van een functionele interface weer te geven.



Voorbeeld: gebruik van een functionele interface met Lambda-expressie

Java
public class Geeks {    public static void main(String[] args) {    // Using lambda expression to implement Runnable  new Thread(() -> System.out.println('New thread created')).start();  } } 

Uitvoer
New thread created 

Uitleg:

  • Bovenstaand programma demonstreert het gebruik van lambda-expressie met de Runnable functionele interface.
  • Runnable heeft één abstracte methode run(), dus deze kwalificeert als een functionele interface.
  • Lambda ()-> System.out.println('Nieuwe thread gemaakt') definieert de run() -methode.
  • new Thread().start() start een nieuwe thread die de lambda-body uitvoert

Opmerking:

A F een onctionele interface kan ook een andere functionele interface uitbreiden.



@FunctioneleInterface Annotatie

@FunctionalInterface-annotatie wordt gebruikt om ervoor te zorgen dat de functionele interface niet meer dan één abstracte methode kan hebben. Als er meer dan één abstracte methode aanwezig is, markeert de compiler een bericht 'Onverwachte @FunctionalInterface-annotatie'. Het is echter niet verplicht om deze annotatie te gebruiken.

Opmerking:

@FunctionalInterface-annotatie is optioneel, maar het is een goede gewoonte om te gebruiken. Het helpt de fout in een vroeg stadium op te sporen door ervoor te zorgen dat de interface slechts één abstracte methode heeft.



Voorbeeld: een functionele interface definiëren met @FunctionalInterface-annotatie

Java
@FunctionalInterface interface Square {  int calculate(int x); } class Geeks {  public static void main(String args[]) {  int a = 5;  // lambda expression to define the calculate method  Square s = (int x) -> x * x;  // parameter passed and return type must be same as defined in the prototype  int ans = s.calculate(a);  System.out.println(ans);  } } 

Uitvoer
25 

Uitleg :

  • Square is een functionele interface met één enkele berekeningsmethode (int x).
  • Een lambda-expressie (int x) -> x * x wordt gebruikt om de berekeningsmethode te implementeren.
  • Lambda neemt x als invoer en retourneert x * x.

Functionele Java-interfaces vóór Java 8

Vóór Java 8 moesten we anonieme innerlijke klassenobjecten maken of deze interfaces implementeren. Hieronder ziet u een voorbeeld van hoe de Runnable-interface werd geïmplementeerd vóór de introductie van lambda-expressies.

Voorbeeld: Java-programma om functionele interface te demonstreren

Java
class Geeks {  public static void main(String args[]) {    // create anonymous inner class object  new Thread(new Runnable() {  @Override public void run()  {  System.out.println('New thread created');  }  }).start();  } } 

Uitvoer
New thread created 

Ingebouwde functionele Java-interfaces

Sinds Java SE 1.8 zijn er veel interfaces die zijn omgezet in functionele interfaces. Al deze interfaces zijn geannoteerd met @FunctionalInterface. Deze interfaces zijn als volgt:

  • Uitvoerbaar: Deze interface bevat alleen de loop() methode.
  • Vergelijkbaar: Deze interface bevat alleen de methode CompareTo().
  • ActieListener: Deze interface bevat alleen de methode actionPerformed().
  • Oproepbaar: Deze interface bevat alleen de methode call().

Soorten functionele interfaces in Java

Java SE 8 bevatte vier belangrijke soorten functionele interfaces die in meerdere situaties kunnen worden toegepast, zoals hieronder vermeld:

  1. Consument
  2. Predikaat
  3. Functie 
  4. Leverancier

1. Consument 

De consumenteninterface van de functionele interface is degene die slechts één argument of een gentrificeerd argument accepteert. De consumenteninterface heeft geen retourwaarde. Het levert niets op. Er zijn ook functionele varianten van de Consument DubbelConsument IntConsument En LangeConsument . Deze varianten accepteren primitieve waarden als argumenten. 

Naast deze varianten is er ook nog een variant van de consumenteninterface bekend als Bi-consument

algoritmen binair zoeken

Syntaxis:

Consument consument = (waarde) -> System.out.println(waarde);

Deze implementatie van de functionele Java Consumer-interface drukt de waarde af die als parameter aan de print-instructie is doorgegeven. Deze implementatie maakt gebruik van de Lambda-functie van Java.

2. Predikaat 

De Predicaat-interface vertegenwoordigt een functie met Booleaanse waarden van één argument. Het wordt vaak gebruikt voor het filteren van bewerkingen in stromen. Net als de functionele consumenteninterface heeft de functionele interface van Predicate ook enkele uitbreidingen. Dit zijn IntPredicaat DubbelPredikaat En LangPredikaat . Dit soort predikaat-functionele interfaces accepteren alleen primitieve gegevenstypen of waarden als argumenten.  

Syntaxis: 

openbare interface Predikaat{
   Booleaanse test(Tt);
}

De functionele Java-predikaatinterface kan ook worden geïmplementeerd met behulp van Lambda-expressies.

sorteer hoop

Predikaat predikaat = (waarde) -> waarde != nul;

3. Functie

A functie is een type functionele interface in Java dat slechts één argument ontvangt en na de vereiste verwerking een waarde retourneert. Veel verschillende versies van de functie-interfaces zijn instrumentaal en worden vaak gebruikt in primitieve typen zoals double int long.

Syntaxis:

Functie functie = (waarde) -> waarde * waarde;

  • Bi-functie: De Bi-functie is substantieel gerelateerd aan een Functie. Bovendien zijn er twee argumenten nodig, terwijl Functie één argument accepteert. 
  • Unaire operator en binaire operator: Er zijn ook twee andere functionele interfaces met de naam Unaire operator En Binaire operator. Ze breiden beide respectievelijk de functie en de bifunctie uit, waarbij zowel het invoertype als het uitvoertype hetzelfde zijn.

4. Leverancier

De Leverancier functionele interface is ook een type functionele interface die geen enkele invoer of argument accepteert en toch één enkele uitvoer retourneert. De verschillende uitbreidingen van de functionele interface van leveranciers bevatten vele andere leveranciersfuncties BooleaanseLeverancier DubbeleLeverancier LangLeverancier En IntLeverancier . Het retourtype van al deze verdere specialisaties bestaat uitsluitend uit de overeenkomstige primitieven. 

Syntaxis:

Leverancierleverancier = () -> 'Hallo wereld!';

Voorbeeld: Predikaatinterface gebruiken om tekenreeksen te filteren

Java
import java.util.*; import java.util.function.Predicate; class Geeks {  public static void main(String args[]) {    // create a list of strings  List<String> n = Arrays.asList('Geek' 'GeeksQuiz' 'g1' 'QA' 'Geek2');  // declare the predicate type as string and use lambda expression to create object  Predicate<String> p = (s) -> s.startsWith('G');  // Iterate through the list  for (String st : n) {    // call the test method  if (p.test(st))  System.out.println(st);  }  } } 

Uitvoer
Geek GeeksQuiz Geek2 

Tabel met functionele interfaces

Functionele interfaces

Beschrijving

Methode

Uitvoerbaar

Het vertegenwoordigt een taak die kan worden uitgevoerd door een thread.

ongeldig uitvoeren()

Vergelijkbaar

binair zoeken

Het vergelijkt twee objecten om te bestellen.

int vergelijkTo(T o)

ActieListener

Het behandelt een actiegebeurtenis in gebeurtenisgestuurde programmering.

void actionPerformed(ActionEvent e)

Oproepbaar

Het vertegenwoordigt een taak die een resultaat kan retourneren of een uitzondering kan genereren.

V call() genereert een uitzondering

Consument

Het accepteert een enkel invoerargument en retourneert geen resultaat.

ongeldig accepteren(T t)

Predikaat

Het accepteert een enkel argument en retourneert een Booleaans resultaat.

Booleaanse test(T t)

Functie

Het accepteert een enkel argument en retourneert een resultaat.

R toepassen(T t)

Leverancier

Er zijn geen argumenten nodig, maar het levert een resultaat op.

T krijg()

BiConsument

Het accepteert twee argumenten en retourneert geen resultaat.

ongeldig accepteren(T t U u)

BiPredicaat

Het accepteert twee argumenten en retourneert een Booleaans resultaat.

Booleaanse test(T t U u)

BiFunctie

Het accepteert twee argumenten en retourneert een resultaat.

Java-switch-instructie

R toepassen(T t U u)

UnaireOperator

Dit is een speciaal geval van Functie waarbij invoer- en uitvoertypen hetzelfde zijn.

T toepassen(T t)

BinaireOperator

Dit is een speciaal geval van BiFunction waarbij de invoer- en uitvoertypen hetzelfde zijn.

T toepassen(T t1 T t2)

Gerelateerde artikelen

  • Java 8
  • Java Lambda-expressies