Et funksjonelt grensesnitt i Java er et grensesnitt som bare inneholder én abstrakt metode. Funksjonelle grensesnitt kan ha flere standardmetoder eller statiske metoder, men bare én abstrakt metode.

Fra Java 8 og utover kan lambda-uttrykk og metodereferanser brukes til å representere forekomsten av et funksjonelt grensesnitt.

Eksempel: Bruk av et funksjonelt grensesnitt med lambdauttrykk

   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  

Forklaring:

• Programmet ovenfor viser bruk av lambda-uttrykk med det funksjonelle grensesnittet Runnable.
• Runnable har en abstrakt metode run() så den kvalifiserer som et funksjonelt grensesnitt.
• Lambda ()-> System.out.println('Ny tråd opprettet') definerer run()-metoden.
• new Thread().start() starter en ny tråd som kjører lambda-kroppen

Note:

EN f unctional interface kan også utvide et annet funksjonelt grensesnitt.

@FunctionalInterface Merknad

@FunctionalInterface-annotering brukes for å sikre at det funksjonelle grensesnittet ikke kan ha mer enn én abstrakt metode. I tilfelle mer enn én abstrakt metode er til stede, flagger kompilatoren en 'Uventet @FunctionalInterface annotation'-melding. Det er imidlertid ikke obligatorisk å bruke denne merknaden.

Note:

@FunctionalInterface-kommentar er valgfritt, men det er en god praksis å bruke. Det hjelper å fange opp feilen på et tidlig stadium ved å sørge for at grensesnittet bare har én abstrakt metode.

Eksempel: Definere et funksjonelt grensesnitt med @FunctionalInterface-annotering

   @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  

Forklaring :

• Square er et funksjonelt grensesnitt med en enkelt metode calculate(int x).
• Et lambda-uttrykk (int x) -> x * x brukes for å implementere beregningsmetoden.
• Lambda tar x som input og returnerer x * x.

Java funksjonelle grensesnitt før Java 8

Før Java 8 måtte vi lage anonyme indre klasseobjekter eller implementere disse grensesnittene. Nedenfor er et eksempel på hvordan Runnable-grensesnittet ble implementert før introduksjonen av lambda-uttrykk.

Eksempel: Java-program for å demonstrere funksjonelt grensesnitt

   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  

Innebygde Java funksjonelle grensesnitt

Siden Java SE 1.8 og utover er det mange grensesnitt som er konvertert til funksjonelle grensesnitt. Alle disse grensesnittene er merket med @FunctionalInterface. Disse grensesnittene er som følger:

• Kjørbar: Dette grensesnittet inneholder kun løp() metode.
• Sammenlignbare: Dette grensesnittet inneholder bare compareTo()-metoden.
• ActionListener: Dette grensesnittet inneholder bare actionPerformed()-metoden.
• Ringbar: Dette grensesnittet inneholder bare call()-metoden.

Typer funksjonelle grensesnitt i Java

Java SE 8 inkluderte fire hovedtyper funksjonelle grensesnitt som kan brukes i flere situasjoner som nevnt nedenfor:

1. Forbruker
2. Predikat
3. Funksjon 
4. Leverandør

1. Forbruker 

De forbrukergrensesnitt av det funksjonelle grensesnittet er det som godtar bare ett argument eller et gentrifisert argument. Forbrukergrensesnittet har ingen returverdi. Det gir ingenting tilbake. Det finnes også funksjonelle varianter av Consumer DoubleConsumer IntConsumer og LongConsumer . Disse variantene aksepterer primitive verdier som argumenter. 

Annet enn disse variantene er det også en variant til av forbrukergrensesnittet kjent som Bi-forbruker . 

Syntaks:

Forbruker forbruker = (verdi) -> System.out.println(verdi);

Denne implementeringen av Java Consumer funksjonelle grensesnitt skriver ut verdien som sendes som en parameter til utskriftssetningen. Denne implementeringen bruker Lambda-funksjonen til Java.

2. Predikat 

De Predikatgrensesnitt representerer en boolsk-verdi funksjon av ett argument. Det brukes ofte for filtreringsoperasjoner i strømmer. Akkurat som Consumer funksjonelt grensesnitt har Predicate funksjonelle grensesnitt også noen utvidelser. Disse er IntPredicate DoublePredicate og LongPredicate . Disse typene funksjonelle predikatgrensesnitt aksepterer bare primitive datatyper eller verdier som argumenter.  

Syntaks: 

offentlig grensesnitt Predikat {
   boolsk test(T t);
}

Java-predikatets funksjonelle grensesnitt kan også implementeres ved hjelp av Lambda-uttrykk.

Predikat predikat = (verdi) -> verdi != null;

3. Funksjon

EN funksjon er en type funksjonelt grensesnitt i Java som mottar bare ett enkelt argument og returnerer en verdi etter den nødvendige behandlingen. Mange forskjellige versjoner av funksjonsgrensesnittene er instrumentelle og brukes ofte i primitive typer som double int long.

Syntaks:

Funksjon funksjon = (verdi) -> verdi * verdi;

• Bi-funksjon: De Bi-funksjon er vesentlig knyttet til en funksjon. Dessuten krever det to argumenter, mens funksjon godtar ett argument. 
• Unær operatør og binær operatør: Det er også to andre funksjonelle grensesnitt som er navngitt som Unær operatør og Binær operatør. De utvider begge funksjonen og bi-funksjonen, der både inngangstypen og utgangstypen er den samme.

4. Leverandør

De Leverandør funksjonelt grensesnitt er også en type funksjonelt grensesnitt som ikke tar noen input eller argument og likevel returnerer en enkelt utgang. De forskjellige utvidelsene av det funksjonelle leverandørgrensesnittet har mange andre leverandørfunksjoner som Boolean Supplier DoubleSupplier LongSupplier og IntSupplier . Returtypen for alle disse ytterligere spesialiseringene er kun deres tilsvarende primitiver. 

Syntaks:

Leverandør leverandør = () -> 'Hei verden!';

Eksempel: Bruke predikatgrensesnitt for å filtrere strenger

   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 over funksjonelle grensesnitt

Relaterte artikler

• Java 8
• Java Lambda-uttrykk