Waar worden functionele interfaces voor gebruikt in Java 8?

Ik kwam een ​​nieuwe term tegen in Java 8: “functionele interface”. Ik kon er maar één gebruik van vinden tijdens het werken met lambda-expressies.

Java 8 biedt enkele ingebouwde functionele interfaces en als we een functionele interface willen definiëren, kunnen we de annotatie @FunctionalInterfacegebruiken. Het stelt ons in staat om slechts één methode in de interface te declareren.

Bijvoorbeeld:

@FunctionalInterface
interface MathOperation {
    int operation(int a, int b);
}

Hoe nuttig is het in Java 8, behalve het werken met lambda-expressies?

(De vraag hieris anders dan degene die ik vroeg. Het vraagt ​​waarom we functionele interfaces nodig hebben als we met lambda-expressies werken. Mijn vraag is: wat zijn de andere toepassingen van functionele interfaces naast het gebruik met lambda-expressies?)

Antwoord 1, autoriteit 100%

@FunctionalInterfaceannotatie is handig voor het controleren van de compilatietijd van uw code. U kunt niet meer dan één methode hebben naast static, defaulten abstracte methoden die methoden in Objectoverschrijven in uw @FunctionalInterfaceof een andere interface die als functionele interface wordt gebruikt.

Maar je kunt lambda’s gebruiken zonder deze annotatie en je kunt methoden overschrijven zonder @Overrideannotatie.

Van documenten

een functionele interface heeft precies één abstracte methode. sinds standaard
methoden hebben een implementatie, ze zijn niet abstract. Als een interface
verklaart een abstracte methode die een van de openbare methodes van . overschrijft
java.lang.Object, dat telt ook niet mee voor de interface’s
abstracte methode tellen aangezien elke implementatie van de interface zal
een implementatie hebben van java.lang.Object of elders

Dit kan worden gebruiktin lambda-expressie:

public interface Foo {
  public void doSomething();
}

Dit kan niet worden gebruiktin lambda-expressie:

public interface Foo {
  public void doSomething();
  public void doSomethingElse();
}

Maar dit geeft compilatiefout:

@FunctionalInterface
public interface Foo {
  public void doSomething();
  public void doSomethingElse();
}

Ongeldige ‘@FunctionalInterface’-annotatie; Foo is niet functioneel
interface

Antwoord 2, autoriteit 17%

De documentatiemaakt inderdaad een verschil tussen het doel

Een informatief annotatietype dat wordt gebruikt om aan te geven dat een interfacetypedeclaratie bedoeld is als een functionele interfacezoals gedefinieerd door de Java-taalspecificatie.

en de use-case

Houd er rekening mee dat instanties van functionele interfaces kunnen worden gemaakt met lambda-expressies, methodeverwijzingen of constructorverwijzingen.

waarvan de formulering andere gebruiksgevallen in het algemeen niet uitsluit. Aangezien het primaire doel is om een ​​functionele interfaceaan te geven, komt uw eigenlijke vraag neer op “Zijn er andere use-cases voorfunctionele interfaces anders dan lambda-expressies en methode/ constructor referenties?”

Aangezien functionele interfaceeen Java-taalconstructie is die is gedefinieerd door de Java-taalspecificatie, kan alleen die specificatie die vraag beantwoorden:

JLS §9.8. Functionele interfaces:

…

Naast het gebruikelijke proces van het maken van een interface-instantie door een klasse te declareren en te instantiëren (§15.9), kunnen instanties van functionele interfaces worden gemaakt met methode-referentie-expressies en lambda-expressies (§15.13, §15.27).

Dus de Java-taalspecificatie zegt niet anders, de enige use case die in die sectie wordt genoemd, is het maken van interface-instanties met methode-referentie-expressies en lambda-expressies. (Dit omvat constructorreferenties zoals ze worden vermeld als een vorm van methode-referentie-expressie in de specificatie).

Dus in één zin, nee, er is geen andere use case voor in Java 8.

Antwoord 3, autoriteit 10%

Zoals anderen al hebben gezegd, is een functionele interface een interface die één methode blootlegt. Het kan meer dan één methode hebben, maar alle andere moeten een standaardimplementatie hebben. De reden dat het een “functionele interface” wordt genoemd, is omdat het effectief als een functie fungeert. Omdat je interfaces als parameters kunt doorgeven, betekent dit dat functies nu “eersteklas burgers” zijn, zoals in functionele programmeertalen. Dit heeft veel voordelen, en je zult ze veel zien bij het gebruik van de Stream API. Natuurlijk zijn lambda-expressies het meest voor de hand liggende gebruik voor hen.

Antwoord 4, autoriteit 9%

Helemaal niet. Lambda-expressies zijn het enige punt van die annotatie.

Antwoord 5, autoriteit 5%

Een lambda-expressie kan worden toegewezen aan een functioneel interfacetype, maar dat geldt ook voor methodeverwijzingen en anonieme klassen.

Een leuk aspect van de specifieke functionele interfaces in java.util.functionis dat ze kunnen worden samengesteld om nieuwe functies te creëren (zoals Function.andThenen Function.compose, Predicate.and, etc.) vanwege de handige standaardmethoden die ze bevatten.

Antwoord 6, autoriteit 4%

Een interface met slechts één abstracte methode wordt Functionele Interface genoemd.
Het is niet verplicht om @FunctionalInterface te gebruiken, maar u kunt het het beste gebruiken met functionele interfaces om te voorkomen dat per ongeluk extra methoden worden toegevoegd. Als de interface is geannoteerd met @FunctionalInterface-annotatie en we proberen meer dan één abstracte methode te hebben, wordt een compilerfout gegenereerd.

package com.akhi;
    @FunctionalInterface
    public interface FucnctionalDemo {
      void letsDoSomething();
      //void letsGo();      //invalid because another abstract method does not allow
      public String toString();    // valid because toString from Object 
      public boolean equals(Object o); //valid
      public static int sum(int a,int b)   // valid because method static
        {   
            return a+b;
        }
        public default int sub(int a,int b)   //valid because method default
        {
            return a-b;
        }
    }

Antwoord 7, autoriteit 3%

Functionele interface:

• Geïntroduceerd in Java 8
• Interface die een “single abstract”-methode bevat.

Voorbeeld 1:

  interface CalcArea {   // --functional interface
        double calcArea(double rad);
    }           

Voorbeeld 2:

interface CalcGeometry { // --functional interface
    double calcArea(double rad);
    default double calcPeri(double rad) {
        return 0.0;
    }
}       

Voorbeeld 3:

interface CalcGeometry {  // -- not functional interface
    double calcArea(double rad);
    double calcPeri(double rad);
}   

Java8-annotatie — @FunctionalInterface

• Annotatie controleer of de interface slechts één abstracte methode bevat. Zo niet, verhoog de fout.
• Hoewel @FunctionalInterface ontbreekt, is het nog steeds een functionele interface (als het een enkele abstracte methode heeft). De annotatie helpt fouten te voorkomen.
• Functionele interface kan extra statische & standaardmethoden.
• bijv. Iterabel<>, Vergelijkbaar<>, Comparator<>.

Toepassingen van functionele interface:

• Methodereferenties
• Lambda-expressie
• Referenties van aannemers

Om functionele interfaces te leren, moet u eerst de standaardmethoden in de interface leren, en nadat u de functionele interface hebt geleerd, zult u gemakkelijk de methodereferentie en lambda-expressie kunnen begrijpen

Antwoord 8

U kunt lambda gebruiken in Java 8

public static void main(String[] args) {
    tentimes(inputPrm - > System.out.println(inputPrm));
    //tentimes(System.out::println);  // You can also replace lambda with static method reference
}
public static void tentimes(Consumer myFunction) {
    for (int i = 0; i < 10; i++)
        myFunction.accept("hello");
}

Voor meer informatie over Java Lambdasen Functionele interfaces

Antwoord 9

@FunctionalInterfaceis een nieuwe annotatie die is uitgebracht met Java 8 en die doeltypen biedt voor lambda-expressies en wordt gebruikt bij het controleren van de compilatietijd van uw code.

Wanneer u het wilt gebruiken:

1- Uw interface mag nietmeer dan één abstracte methode hebben, anders krijgt u een compilatiefout.

1- Uw interface Moetpuur zijn, wat betekent dat de functionele interface bedoeld is om te worden geïmplementeerd door staatloze klassen, een voorbeeld van puur is de Comparator-interface omdat het niet afhankelijk is van de uitvoerders stellen, in dit geval zal Geencompilatiefout worden gegeven, maar in veel gevallen zult u lambda niet kunnen gebruiken met dit soort interfaces

Het pakket java.util.functionbevat verschillende functionele interfaces voor algemene doeleinden, zoals Predicate, Consumer, Function, en Supplier.

Houd er rekening mee dat u lambda’s kunt gebruiken zonder deze annotatie.

Antwoord 10

Naast andere antwoorden, denk ik dat de belangrijkste reden voor “waarom het gebruik van een andere functionele interface dan rechtstreeks met lambda-expressies” te maken kan hebben met de aard van de Java-taal die objectgeoriënteerd is.

De belangrijkste kenmerken van Lambda-expressies zijn: 1. Ze kunnen worden doorgegeven 2. en ze kunnen in de toekomst in een bepaalde tijd (meerdere keren) worden uitgevoerd. Om deze functie nu in talen te ondersteunen, behandelen sommige andere talen deze kwestie eenvoudig.

In Java Script kan bijvoorbeeld een functie (anonieme functie of letterlijke functies) worden aangesproken als een object. U kunt ze dus eenvoudig maken en ze kunnen ook worden toegewezen aan een variabele, enzovoort. Bijvoorbeeld:

var myFunction = function (...) {
    ...;
}
alert(myFunction(...));

of via ES6, je kunt een pijlfunctie gebruiken.

const myFunction = ... => ...

Tot nu toe hebben Java-taalontwerpers niet geaccepteerd om genoemde functies op deze manier af te handelen (functionele programmeertechnieken). Ze zijn van mening dat Java-taal objectgeoriënteerd is en daarom zouden ze dit probleem moeten oplossen via objectgeoriënteerde technieken. Ze willen de eenvoud en consistentie van de Java-taal niet missen.

Daarom gebruiken ze interfaces, zoals wanneer een object van een interface met slechts één methode (ik bedoel functionele interface) nodig is, je het kunt vervangen door een lambda-expressie. Zoals:

ActionListener listener = event -> ...;

Antwoord 11

Functionele interfaces: een interface wordt een functionele interface genoemd als deze een enkele abstracte methode heeft, ongeacht het aantal standaard- of statische methoden. Functionele interface wordt gebruikt voor lamda-expressie. Runnable, Callable, Comparable, Comparatorzijn enkele voorbeelden van FunctionalInterface.

KeyNotes:

• Annotatie @FunctionalInterfacewordt gebruikt (optioneel).
• Het zou slechts 1 abstracte methode moeten hebben (ongeacht het aantal standaard en statische)
  methoden).
• Twee abstracte methoden geven een compilatiefout (Provider @FunctionalInterfaceannotatie is
  gebruikt).

Deze threadvertelt meer in detail over welk voordeel functionele interface geeft anonieme klasse over en hoe ze te gebruiken.