Java har för alltid förblivit ett objektorienterat programmeringsspråk. Med objektorienterat programmeringsspråk kan vi deklarera att allt som finns i Java-programmeringsspråket roterar genom objekten, förutom några av de primitiva datatyperna och primitiva metoderna för integritet och enkelhet. Det finns inga enbart funktioner i ett programmeringsspråk som kallas Java. Funktioner i programmeringsspråket Java är en del av en klass, och om någon vill använda dem måste de använda klassen eller objektet i klassen för att anropa vilken funktion som helst.

Java funktionella gränssnitt

A funktionellt gränssnitt är ett gränssnitt som bara innehåller en abstrakt metod. De kan bara ha en funktion att visa upp. Från Java 8 och framåt, lambda uttryck kan användas för att representera instansen av ett funktionellt gränssnitt. Ett funktionellt gränssnitt kan ha valfritt antal standardmetoder. Körbar , ActionListener , och Jämförbar är några av exemplen på funktionella gränssnitt.

Funktionellt gränssnitt är dessutom känt som Enkla abstrakta metodgränssnitt . Kort sagt, de är också kända som SAM-gränssnitt . Funktionella gränssnitt i Java är den nya funktionen som ger användarna principen om grundläggande programmering.

Funktionella gränssnitt ingår i Java SE 8 med Lambda-uttryck och metodreferenser för att göra koden mer läsbar, ren och okomplicerad. Funktionella gränssnitt är gränssnitt som säkerställer att de innehåller just en abstrakt metod. Funktionella gränssnitt används och exekveras genom att representera gränssnittet med en anteckning anropad @FunctionalInterface . Som beskrivits tidigare kan funktionella gränssnitt endast innehålla en abstrakt metod. De kan dock inkludera vilken mängd standardmetoder som helst och statiska metoder.

I funktionella gränssnitt finns det inget behov av att använda det abstrakta nyckelordet eftersom det är valfritt att använda det abstrakta nyckelordet eftersom den metod som definieras i gränssnittet som standard endast är abstrakt. Vi kan också kalla Lambda-uttryck som instans av funktionellt gränssnitt.

Java Functional Interfaces Exempel

Exempel 1:

Innan Java 8 var vi tvungna att skapa anonyma inre klassobjekt eller implementera dessa gränssnitt.

Java

>

genomgång av binärt träd i ordning

>

New thread created>

Exempel 2:

strängdelning c++

Java 8 och framåt kan vi tilldela lambda uttryck till dess funktionella gränssnittsobjekt så här:

Java

>

>

New thread created>

@FunctionalInterface Annotation

@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 finns, flaggar kompilatorn ett meddelande om 'Oväntad @FunctionalInterface-anteckning'. Det är dock inte obligatoriskt att använda denna anteckning.

Nedan är implementeringen av ovanstående ämne:

Java

vad är orakel

>

>

25>

Vissa 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 följande –

Körbar –> Det här gränssnittet innehåller bara metoden run(). Comparable –> Det här gränssnittet innehåller bara metoden compareTo(). ActionListener –> Det här gränssnittet innehåller bara metoden actionPerformed(). Callable –> Det här gränssnittet innehåller bara metoden call().

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

Consumer Predicate Function Leverantör

Bland de föregående fyra gränssnitten har de tre första gränssnitten, dvs. Konsument, Predikat och Funktion, också tillägg som tillhandahålls nedan -

1. Konsument -> Bi-Consumer
2. Predikat -> Bi-predikat
3. Funktion -> Bi-Function, Unary Operator, Binary Operator

1. Konsument

Konsumentgränssnittet för det funktionella gränssnittet är det som endast accepterar ett argument eller ett gentrifierat argument. Konsumentgränssnittet har inget returvärde. Det ger ingenting tillbaka. Det finns också 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.

Bi-Consumer – Bi-Consumer är den mest spännande varianten av konsumentgränssnittet. Konsumentgränssnittet tar bara ett argument, men på andra sidan tar Bi-Consumer-gränssnittet två argument. Både Consumer och Bi-Consumer har inget returvärde. Det ger inte heller något som konsumentgränssnittet. Den används för att iterera genom kartans poster.

Syntax/prototyp av konsumentfunktionellt gränssnitt –

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

Inom vetenskaplig logik kallas en funktion som accepterar ett argument och i gengäld genererar ett booleskt värde som ett svar ett predikat. På liknande sätt, i programmeringsspråket Java, är ett funktionellt predikatgränssnitt för Java en typ av funktion som accepterar ett enda värde eller argument och gör någon form av bearbetning på det, och returnerar ett booleskt (Sant/falskt) svar. Implementeringen av det funktionella gränssnittet Predicate inkapslar också logiken för filtrering (en process som används för att filtrera strömkomponenter på basen av ett tillhandahållet predikat) i Java.

Precis som Consumer funktionsgränssnittet har Predicate funktionella grä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.

Bi-predikat – Bi-Predicate är också en förlängning av det funktionella gränssnittet Predicate, som istället för ett tar två argument, gör en del bearbetning och returnerar det booleska värdet.

Syntax för predikat funktionellt gränssnitt –

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

Det funktionella gränssnittet för predikatet kan också implementeras med hjälp av en klass. Syntaxen för implementering av predikatfunktionellt gränssnitt med en klass ges nedan -

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

Java-predikatets funktionella gränssnitt kan också implementeras med Lambda-uttryck. Ett exempel på implementeringen av det funktionella gränssnittet Predicate ges nedan –

Predicate predicate = (value) ->värde != null;>

Denna implementering av funktionella gränssnitt i Java med Java Lambda-uttryck är mer hanterbar och effektiv än den som implementeras med en klass eftersom båda implementeringarna gör samma arbete, dvs. returnerar samma utdata.

3. Funktion

En funktion är en typ av funktionellt gränssnitt i Java som endast tar emot ett enda argument och returnerar ett värde efter den nödvändiga bearbetningen. Det finns många versioner av funktionsgränssnitt eftersom en primitiv typ inte kan antyda ett generellt typargument, så vi behöver dessa versioner av funktionsgränssnitt. Många olika versioner av funktionsgränssnitten är instrumentella och används ofta i primitiva typer som dubbel, int, lång. De olika sekvenserna av dessa primitiva typer används också i argumentationen.

java om annat

Dessa versioner är:

Bi-funktion

Bi-funktionen är väsentligen relaterad till en funktion. Dessutom krävs två argument, medan Funktion accepterar ett argument.

Prototypen och syntaxen för Bi-Function ges nedan -

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

I ovanstående gränssnittskod är T och U ingångarna, och det finns bara en utgång som är R.

Unär operatör och binär operatör

Det finns också två andra funktionella gränssnitt som heter Unary Operator och Binary Operator. De utökar båda funktionen respektive Bi-funktionen. Med enkla ord utökar Unary Operator Funktion och Binary Operator utökar Bi-Function.

Prototypen av Unary Operator och Binary Operator nämns nedan:

i. Unär operatör

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

ii . Binär operatör

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

Vi kan förstå framför exemplet ovan att Unary Operator endast accepterar ett argument och returnerar endast ett enda argument. Ändå, i Unary Operator måste både ingångs- och utgångsvärdena vara identiska och av samma typ.

Å andra sättet tar Binary Operator två värden och returnerar ett värde som är jämförbart med Bi-Function men liknar en Unary Operator, ingångs- och utdatavärdetyperna måste vara identiska och av samma typ.

latex teckenstorlek

4. Leverantör

Leverantörens funktionella gränssnitt är också en typ av funktionellt gränssnitt som inte tar någon input eller argument och ändå returnerar en enda utgång. Den här typen av funktionellt gränssnitt används vanligtvis i den lata genereringen av värden. Leverantörens funktionella gränssnitt används också för att definiera logiken för genereringen av valfri sekvens. Till exempel – Logiken bakom Fibonacci-serien kan genereras med hjälp av Stream. genereringsmetod, som implementeras av leverantörens funktionella gränssnitt.

De olika tilläggen av leverantörens funktionella gränssnitt har många andra leverantörsfunktioner som BooleanSupplier, DoubleSupplier, LongSupplier och IntSupplier. Returtypen för alla dessa ytterligare specialiseringar är endast deras motsvarande primitiver.

Syntax/prototyp för leverantörens funktionella gränssnitt är –

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

Nedan är implementeringen av ovanstående ämne:

Java

>

>

Geek GeeksQuiz Geek2>

Viktiga poäng/observationer ns:

Här är några viktiga punkter angående funktionella gränssnitt i Java:

1. I funktionella gränssnitt finns det bara en abstrakt metod som stöds. Om annoteringen av ett funktionellt gränssnitt, d.v.s. @FunctionalInterface inte implementeras eller skrivs med ett funktionsgränssnitt, kan mer än en abstrakt metod deklareras inuti det. Men i den här situationen med mer än en funktion kommer det gränssnittet inte att kallas ett funktionellt gränssnitt. Det kallas ett icke-funktionellt gränssnitt.
2. Det finns inget sådant behov av @FunctionalInterface-anteckningen eftersom den endast är frivillig. Detta är skrivet för att det hjälper till att kontrollera kompilatornivån. Förutom detta är det valfritt.
3. Ett oändligt antal metoder (oavsett om det är statiskt eller standard) kan läggas till det funktionella gränssnittet. Med enkla ord finns det ingen gräns för ett funktionellt gränssnitt som innehåller statiska metoder och standardmetoder.
4. Åsidosättande av metoder från den överordnade klassen bryter inte mot reglerna för ett funktionellt gränssnitt i Java.
5. De java.util.funktion Paketet innehåller många inbyggda funktionella gränssnitt i Java 8.