Java is voor altijd een objectgeoriënteerde programmeertaal gebleven. Met objectgeoriënteerde programmeertaal kunnen we verklaren dat alles wat aanwezig is in de Java-programmeertaal door de objecten roteert, met uitzondering van enkele van de primitieve gegevenstypen en primitieve methoden voor integriteit en eenvoud. Er zijn niet alleen functies aanwezig in een programmeertaal genaamd Java. Functies in de Java-programmeertaal maken deel uit van een klasse, en als iemand ze wil gebruiken, moet hij de klasse of het object van de klasse gebruiken om een ​​functie aan te roepen.

Functionele Java-interfaces

A functionele interface is een interface die slechts één abstracte methode bevat. Ze kunnen slechts één functionaliteit vertonen. Vanaf Java 8 is lambda-uitdrukkingen kan worden gebruikt om de instantie van een functionele interface weer te geven. Een functionele interface kan een willekeurig aantal standaardmethoden hebben. Uitvoerbaar , ActieListener , En Vergelijkbaar zijn enkele voorbeelden van functionele interfaces.

Functionele interface wordt bovendien erkend als Enkele abstracte methode-interfaces . Kortom, ze worden ook wel genoemd SAM-interfaces . Functionele interfaces in Java zijn de nieuwe functie die gebruikers de benadering van fundamenteel programmeren biedt.

if en else in bash

Functionele interfaces zijn opgenomen in Java SE 8 met Lambda-expressies en methodereferenties om de code leesbaarder, overzichtelijker en eenvoudiger te maken. Functionele interfaces zijn interfaces die ervoor zorgen dat ze precies één abstracte methode bevatten. Functionele interfaces worden gebruikt en uitgevoerd door de interface weer te geven met een annotatie genoemd @FunctioneleInterface . Zoals eerder beschreven kunnen functionele interfaces slechts één abstracte methode bevatten. Ze kunnen echter een willekeurig aantal standaard- en statische methoden bevatten.

In functionele interfaces is het niet nodig om het abstracte trefwoord te gebruiken, omdat het optioneel is om het abstracte trefwoord te gebruiken, omdat de methode die in de interface is gedefinieerd standaard alleen abstract is. We kunnen Lambda-expressies ook de instantie van een functionele interface noemen.

Voorbeeld van functionele Java-interfaces

Voorbeeld 1:

Vóór Java 8 moesten we anonieme innerlijke klassenobjecten maken of deze interfaces implementeren.

Java

>

>

New thread created>

Voorbeeld 2:

Java 8 en hoger kunnen we toewijzen lambda-expressie naar het functionele interface-object als volgt:

Java

Salman Khan leeftijd

>

>

New thread created>

@FunctionalInterface-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.

Hieronder vindt u de implementatie van het bovenstaande onderwerp:

Java

>

>

25>

Enkele 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 run() -methode. Vergelijkbaar -> Deze interface bevat alleen de methode CompareTo(). ActionListener –> Deze interface bevat alleen de actionPerformed() methode. Oproepbaar -> Deze interface bevat alleen de methode call().

Java SE 8 bevatte vier belangrijke soorten functionele interfaces die in meerdere situaties kan worden toegepast, zoals hieronder vermeld:

als anders als anders java

Consument Predikaatfunctie Leverancier

Te midden van de voorgaande vier interfaces hebben de eerste drie interfaces, namelijk Consumer, Predicate en Function, eveneens toevoegingen die hieronder worden gegeven:

1. Consument -> Bi-consument
2. Predikaat -> Bi-predikaat
3. Functie -> Bi-functie, unaire operator, binaire operator

1. Consument

De consumenteninterface van de functionele interface is degene die slechts één argument of een gentrified argument accepteert. De consumenteninterface heeft geen retourwaarde. Het levert niets op. Er zijn ook functionele varianten van de Consumer: DoubleConsumer, IntConsumer en LongConsumer. Deze varianten accepteren primitieve waarden als argumenten.

Naast deze varianten is er nog een variant van de consumenteninterface die bekend staat als Bi-Consumer.

Bi-consument – Bi-Consumer is de meest opwindende variant van de Consumer-interface. De consumenteninterface accepteert slechts één argument, maar aan de andere kant accepteert de Bi-Consumer-interface twee argumenten. Zowel Consumer als Bi-Consumer hebben geen retourwaarde. Het retourneert ook niets, net als de consumenteninterface. Het wordt gebruikt bij het doorlopen van de gegevens op de kaart.

Syntaxis / prototype van functionele consumenteninterface –

Consumer consumer = (value) ->Systeem.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

In de wetenschappelijke logica wordt een functie die een argument accepteert en in ruil daarvoor een Booleaanse waarde als antwoord genereert, een predikaat genoemd. Op dezelfde manier is een predikaat-functionele interface van Java in de Java-programmeertaal een type functie dat een enkele waarde of argument accepteert en er een soort verwerking op uitvoert, en een booleaans (waar/onwaar) antwoord retourneert. De implementatie van de functionele Predicaat-interface omvat ook de logica van filteren (een proces dat wordt gebruikt om stroomcomponenten te filteren op basis van een verstrekt predikaat) in Java.

Net als de functionele consumenteninterface heeft de functionele interface van Predicate ook enkele uitbreidingen. Dit zijn IntPredicate, DoublePredicate en LongPredicate. Dit soort predikaat-functionele interfaces accepteren alleen primitieve gegevenstypen of waarden als argumenten.

Bi-predikaat – Bi-Predicate is ook een uitbreiding van de functionele interface Predicate, die, in plaats van één, twee argumenten aanneemt, enige verwerking uitvoert en de Booleaanse waarde retourneert.

Syntaxis van predicaat functionele interface –

public interface Predicate { boolean test(T t); }>

De predikaat-functionele interface kan ook worden geïmplementeerd met behulp van een klasse. De syntaxis voor de implementatie van een predikaat-functionele interface met behulp van een klasse wordt hieronder gegeven:

public class CheckForNull implements Predicate { @Override public boolean test(Object o) { return o != null; } }>

De functionele Java-predikaatinterface kan ook worden geïmplementeerd met behulp van Lambda-expressies. Een voorbeeld van de implementatie van de functionele interface Predicate wordt hieronder gegeven:

Predicate predicate = (value) ->waarde != nul;>

Deze implementatie van functionele interfaces in Java met behulp van Java Lambda-expressies is beter beheersbaar en effectiever dan de implementatie die is geïmplementeerd met behulp van een klasse, omdat beide implementaties hetzelfde werk doen, dat wil zeggen dezelfde uitvoer retourneren.

3. Functie

Een functie is een type functionele interface in Java dat slechts één argument ontvangt en na de vereiste verwerking een waarde retourneert. Er zijn veel versies van functie-interfaces omdat een primitief type geen algemeen type-argument kan impliceren, dus hebben we deze versies van functie-interfaces nodig. Veel verschillende versies van de functie-interfaces zijn instrumentaal en worden vaak gebruikt in primitieve typen zoals double, int, long. De verschillende reeksen van deze primitieve typen worden ook in het argument gebruikt.

Deze versies zijn:

Bi-functie

De Bi-Functie is substantieel gerelateerd aan een Functie. Bovendien zijn er twee argumenten nodig, terwijl Functie één argument accepteert.

Het prototype en de syntaxis van Bi-Function worden hieronder gegeven:

@FunctionalInterface public interface BiFunction { R apply(T t, U u); ....... }>

In de bovenstaande interfacecode zijn T en U de ingangen, en er is slechts één uitgang, namelijk R.

Snel sorteren

Unaire operator en binaire operator

Er zijn ook twee andere functionele interfaces die Unary Operator en Binary Operator worden genoemd. Ze breiden beide respectievelijk de functie en bi-functie uit. In eenvoudige bewoordingen breidt Unary Operator de functie uit, en Binary Operator breidt Bi-Function uit.

Het prototype van de Unaire Operator en Binaire Operator wordt hieronder vermeld:

i. Unaire operator

@FunctionalInterface public interface UnaryOperator extends Function { ……... }>

ii . Binaire operator

@FunctionalInterface public interface BinaryOperator extends BiFunction { ……... }>

Uit het bovenstaande voorbeeld kunnen we begrijpen dat de Unaire Operator slechts één argument accepteert en slechts één argument retourneert. Toch moeten in Unary Operator zowel de invoer- als de uitvoerwaarden identiek zijn en van hetzelfde type zijn.

Aan de andere kant neemt de Binaire Operator twee waarden en retourneert één waarde die vergelijkbaar is met Bi-Function, maar vergelijkbaar met een Unaire Operator. De invoer- en uitvoerwaardetypen moeten identiek zijn en van hetzelfde type.

vergelijk met Java

4. Leverancier

De functionele interface van de leverancier is ook een soort functionele interface die geen enkele invoer of argument accepteert en toch één enkele uitvoer retourneert. Dit type functionele interface wordt over het algemeen gebruikt bij het luie genereren van waarden. Functionele interfaces van leveranciers worden ook gebruikt voor het definiëren van de logica voor het genereren van een reeks. Bijvoorbeeld: de logica achter de Fibonacci-reeks kan worden gegenereerd met behulp van de Stream. methode genereren, die wordt geïmplementeerd door de functionele interface van de leverancier.

De verschillende uitbreidingen van de functionele interface van de leverancier bevatten vele andere leveranciersfuncties, zoals BooleanSupplier, DoubleSupplier, LongSupplier en IntSupplier. Het retourtype van al deze verdere specialisaties bestaat uitsluitend uit de overeenkomstige primitieven.

Syntaxis / prototype van functionele interface van leverancier is –

@FunctionalInterface public interface Supplier{ // gets a result …………. // returns the specific result ………… T.get(); }>

Hieronder vindt u de implementatie van het bovenstaande onderwerp:

Java

>

>

Geek GeeksQuiz Geek2>

Belangrijke punten/observatie NS:

Hier zijn enkele belangrijke punten met betrekking tot functionele interfaces in Java:

1. In functionele interfaces wordt slechts één abstracte methode ondersteund. Als de annotatie van een functionele interface, d.w.z. @FunctionalInterface, niet is geïmplementeerd of geschreven met een functie-interface, kan daarin meer dan één abstracte methode worden gedeclareerd. In deze situatie met meer dan één functie wordt die interface echter geen functionele interface genoemd. Het wordt een niet-functionele interface genoemd.
2. De annotatie @FunctionalInterface is niet nodig, omdat deze alleen vrijwillig is. Dit is geschreven omdat het helpt bij het controleren van het compilerniveau. Daarnaast is het optioneel.
3. Er kan een oneindig aantal methoden (statisch of standaard) aan de functionele interface worden toegevoegd. In eenvoudige woorden: er is geen limiet aan een functionele interface die statische en standaardmethoden bevat.
4. Het overschrijven van methoden uit de bovenliggende klasse is niet in strijd met de regels van een functionele interface in Java.
5. De java.util.functie pakket bevat veel ingebouwde functionele interfaces in Java 8.