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
Javapublic class Geeks { public static void main(String[] args) { // Using lambda expression to implement Runnable new Thread(() -> System.out.println('New thread created')).start(); } }
Produktion
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
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); } }
Produktion
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
Javaclass 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(); } }
Produktion
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:
- Konsument
- Predikat
- Fungera
- 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.
postorder traversal
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.
för loopar java
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
Javaimport 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); } } }
Produktion
Geek GeeksQuiz Geek2
Tabell över funktionella gränssnitt
Funktionella gränssnitt | Beskrivning | Metod |
---|---|---|
Körbar | Det representerar en uppgift som kan utföras av en tråd. | void run() |
Jämförbar | Den jämför två objekt för beställning. | int compareTo(T o) |
ActionListener salman khan khan ålder | Den hanterar en actionhändelse i händelsedriven programmering. | void actionPerformed(ActionEvent e) |
Ringbar | Det representerar en uppgift som kan returnera ett resultat eller skapa ett undantag. | V call() kastar undantag |
Konsument | Den accepterar ett enda inmatningsargument och returnerar inget resultat. | void acceptera(T t) |
Predikat | Den accepterar ett enda argument och returnerar ett booleskt resultat. | booleskt test(T t) |
Fungera | Den accepterar ett enda argument och returnerar ett resultat. | R tillämpa(T t) |
Leverantör | Det kräver inga argument utan ger ett resultat. | T få() java boolean till sträng |
BiConsumer | Den accepterar två argument och ger inget resultat. | void acceptera(T t U u) |
BiPredikat | Den accepterar två argument och returnerar ett booleskt resultat. | booleskt test (T t U u) |
BiFunction | Den accepterar två argument och returnerar ett resultat. | R tillämpa(T t U u) |
UnaryOperator | Detta är ett specialfall av funktion där ingångs- och utmatningstyper är samma. | T tillämpa(T t) |
BinaryOperator | Detta är ett specialfall av BiFunction där ingångs- och utgångstyper är samma. | T tillämpas (T t1 T t2) |
Relaterade artiklar
- Java 8
- Java Lambda-uttryck