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
Javapublic 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
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(); } }
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:
- Consument
- Predikaat
- Functie
- 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:
Leverancier
leverancier = () -> 'Hallo wereld!';
Voorbeeld: Predikaatinterface gebruiken om tekenreeksen te filteren
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); } } }
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