Ett funktionellt gränssnitt i Java är ett gränssnitt som bara innehåller en abstrakt metod. Funktionella gränssnitt kan ha flera standardmetoder eller statiska metoder men bara en abstrakt metod.

Från Java 8 och framåt kan lambda-uttryck och metodreferenser användas för att representera instansen av ett funktionellt gränssnitt.

Exempel: Använda ett funktionellt gränssnitt med lambdauttryck

   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  

Förklaring:

• Programmet ovan visar användningen av lambda-uttryck med det funktionella gränssnittet Runnable.
• Runnable har en abstrakt metod run() så den kvalificerar sig som ett funktionellt gränssnitt.
• Lambda ()-> System.out.println('Ny tråd skapad') definierar run()-metoden.
• new Thread().start() startar en ny tråd som kör lambdakroppen

Notera:

A f unctional interface kan också utöka ett annat funktionellt gränssnitt.

@FunctionalInterface Anteckning

@FunctionalInterface-anteckning används för att säkerställa att det funktionella gränssnittet inte kan ha mer än en abstrakt metod. Om mer än en abstrakt metod är närvarande flaggar kompilatorn ett "Oväntad @FunctionalInterface annotation"-meddelande. Det är dock inte obligatoriskt att använda denna anteckning.

Notera:

@FunctionalInterface-anteckning är valfri men det är en bra praxis att använda. Det hjälper till att fånga felet i ett tidigt skede genom att se till att gränssnittet bara har en abstrakt metod.

Exempel: Definiera ett funktionellt gränssnitt med @FunctionalInterface-anteckning

   @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  

Förklaring :

• Square är ett funktionellt gränssnitt med en enda metod calculate(int x).
• Ett lambdauttryck (int x) -> x * x används för att implementera beräkningsmetoden.
• Lambda tar x som indata och returnerar x * x.

Java funktionella gränssnitt före Java 8

Innan Java 8 var vi tvungna att skapa anonyma inre klassobjekt eller implementera dessa gränssnitt. Nedan är ett exempel på hur Runnable-gränssnittet implementerades före introduktionen av lambda-uttryck.

Exempel: Java-program för att visa funktionellt gränssnitt

   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  

Inbyggda Java funktionella gränssnitt

Sedan Java SE 1.8 och framåt finns det många gränssnitt som konverteras till funktionella gränssnitt. Alla dessa gränssnitt är kommenterade med @FunctionalInterface. Dessa gränssnitt är som följer:

• Körbar: Detta gränssnitt innehåller endast sikt() metod.
• Jämförbar: Det här gränssnittet innehåller bara metoden compareTo().
• ActionListener: Det här gränssnittet innehåller endast metoden actionPerformed().
• Ringbar: Det här gränssnittet innehåller bara metoden call().

Typer av funktionella gränssnitt i Java

Java SE 8 inkluderade fyra huvudtyper av funktionella gränssnitt som kan användas i flera situationer som nämns nedan:

1. Konsument
2. Predikat
3. Fungera 
4. Leverantör

1. Konsument 

De konsumentgränssnitt av det funktionella gränssnittet är det som bara accepterar ett argument eller ett gentrifierat argument. Konsumentgränssnittet har inget returvärde. Det ger ingenting tillbaka. Det finns även funktionella varianter av Consumer DoubleConsumer IntConsumer och LongConsumer . Dessa varianter accepterar primitiva värden som argument. 

Förutom dessa varianter finns det också en variant till av konsumentgränssnittet som kallas Bi-Consumer . 

Syntax:

Konsument konsument = (värde) -> System.out.println(värde);

Denna implementering av Java Consumer funktionella gränssnitt skriver ut värdet som skickas som en parameter till print-satsen. Denna implementering använder Lambda-funktionen i Java.

2. Predikat 

De Predikatgränssnitt representerar en booleskt värderad funktion av ett argument. Det används vanligtvis för filtreringsoperationer i strömmar. Precis som Consumer funktionsgränssnittet har Predicate funktionsgränssnitt också några tillägg. Dessa är IntPredicate DoublePredicate och LongPredicate . Dessa typer av predikatfunktionella gränssnitt accepterar endast primitiva datatyper eller värden som argument.  

Syntax: 

publikt gränssnitt Predikat {
   booleskt test(Tt);
}

Java-predikatets funktionella gränssnitt kan också implementeras med Lambda-uttryck.

Predikat predikat = (värde) -> värde != null;

3. Funktion

A fungera är en typ av funktionellt gränssnitt i Java som bara tar emot ett enda argument och returnerar ett värde efter den nödvändiga bearbetningen. Många olika versioner av funktionsgränssnitten är instrumentella och används ofta i primitiva typer som dubbel int long.

Syntax:

Fungera funktion = (värde) -> värde * värde;

• Bi-funktion: De Bi-funktion är väsentligen relaterad till en funktion. Dessutom krävs två argument medan Function accepterar ett argument. 
• Unär operatör och binär operatör: Det finns också två andra funktionella gränssnitt som heter som Unär operatör och Binär operatör. De utökar båda Funktionen respektive Bi-funktionen där både ingångstypen och utgångstypen är samma.

4. Leverantör

De Leverantör funktionellt gränssnitt är också en typ av funktionellt gränssnitt som inte tar någon input eller argument och som ändå returnerar en enda utgång. De olika tilläggen av det funktionella gränssnittet för leverantörer har många andra leverantörsfunktioner som Boolean Supplier DoubleSupplier LongSupplier och IntSupplier . Returtypen för alla dessa ytterligare specialiseringar är endast deras motsvarande primitiver. 

Syntax:

Leverantör leverantör = () -> 'Hej världen!';

Exempel: Använda predikatgränssnitt för att filtrera strängar

   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  

Tabell över funktionella gränssnitt

Relaterade artiklar

• Java 8
• Java Lambda-uttryck