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

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

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

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

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

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

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 . 

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.

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:

Leverancier leverancier = () -> 'Hallo wereld!';

Voorbeeld: Predikaatinterface gebruiken om tekenreeksen te filteren

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

Geek GeeksQuiz Geek2  

Tabel met functionele interfaces

Gerelateerde artikelen

• Java 8
• Java Lambda-expressies