Detaljerad förklaring av vanliga funktionella gränssnitt (delegater) i Java

Lilla avskum · Publicerad på 2021-09-16 09:28:21

JDK 1.8 API innehåller många inbyggda funktionella gränssnitt, såsom Comparator eller Runnable-gränssnitten som ofta användes i gammal Java, vilka lägger till @FunctionalInterface annotationer så att de kan användas på lambdas. Nu ska vi verkligen förstå det från ingången av vanliga funktioner i Funktionen.

Namn	typ	beskrivning
Konsument	Konsument< T >	Tar emot T-objekt, returnerar inga värden
Predikat	Predikat< T >	Tar emot T-objektet och returnerar booleanen
Funktion	Funktion< T, R >	Tar emot T-objekt och returnerar R-objekt
Leverantör	Leverantör< T >	Tillhandahålla T-objekt (t.ex. växter) utan att acceptera värden
UnaryOperator	UnaryOperator	Tar emot T-objekt och returnerar T-objekt
BinärOperator	BinärOperator	Ta emot två T-objekt och returnera T-objekt

Ett gränssnitt märkt som FunctionalInterface kallas ett funktionellt gränssnitt, som endast kan ha en anpassad metod, men kan inkludera metoder ärvda från objektklassen. Om ett gränssnitt bara har en metod, kommer kompilatorn att tro att det är ett fungerande gränssnitt. Oavsett om det är ett funktionellt gränssnitt eller inte måste följande punkter noteras:

Annotationen kan endast markeras på gränssnitt med "Det finns bara en abstrakt metod".
De statiska och standardmetoderna i JDK8-gränssnittet är inte abstrakta metoder.
Gränssnittet ärver som standard java.lang.Object, så om gränssnittet visar att deklarationen åsidosätter metoden i objektet betraktas den inte som en abstrakt metod.
Annotationen krävs inte, och om ett gränssnitt uppfyller definitionen av ett "funktionellt gränssnitt" har det ingen effekt på om annoteringen läggs till eller inte. Dessutom gör annoteringen att kompilatorn kan kontrollera bättre. Om du skriver ett icke-fungerande gränssnitt men lägger till @FunctionInterface, kommer kompilatorn att rapportera ett fel.
Att definiera två anpassade metoder i ett gränssnitt resulterar i en ogiltig '@FunctionalInterface'-annotering; FunctionalInterfaceTest är inte ett funktionellt gränssnittsfel.

java.util.function Den innehåller ett antal klasser för att stödja Javas funktionella programmering, och de funktionella gränssnitten i detta paket är:

serienummer	Gränssnitt & Beskrivning
1	BiConsumer<T,U> Representerar en åtgärd som accepterar två indataparametrar och inte ger några resultat
2	BiFunktion<T,U,R> Representerar en metod som accepterar två indataparametrar och returnerar ett resultat
3	BinärOperator<T> representerar en handling som verkar på två operatorer av samma typ, och returnerar resultatet av samma typ av operator
4	BiPredicate<T,U> Representerar en tvåparametrs boolesk värdemetod
5	BooleanSupplier Representerar leverantören av det boolska värderesultatet
6	Konsument<T> Representerar en operation som accepterar en indataparameter och inte returnerar något
7	DoubleBinaryOperator representerar en handling som verkar på två dubbelvärdiga operatorer och returnerar resultatet av ett dubbelvärde.
8	DoubleConsumer Representerar en handling som accepterar en dubbelvärdeparameter och inte returnerar något resultat.
9	DoubleFunction<R> Representerar en metod som accepterar en dubbelvärd parameter och returnerar resultatet
10	Dubbelpredikat Representerar en boolesk värdemetod med en dubbelvärdeparameter
11	DoubleSupplier Representerar leverantören av en dubbelvärdesstruktur
12	DoubleToIntFunction Accepterar en dubbeltyp-indata och returnerar ett int-typresultat.
13	DoubleToLongFunction Accepterar en dubbeltyp-indata och returnerar ett långtypresultat
14	DoubleUnaryOperator Acceptera en parameter av samma typ dubbelt, och returvärdestypen är också dubbel.
15	Funktion<T,R> Accepterar en indataparameter, returnerar ett resultat.
16	IntBinaryOperator Acceptera båda parametrarna av typen int, och returnera värdetypen int.
17	IntConsumer Accepterar en indataparameter av typen int utan något returvärde.
18	IntFunction<R> Accepterar en int-typ indataparameter och returnerar ett resultat.
19	Intpredikat : Accepterar en int-indataparameter och returnerar ett boolskt resultat.
20	IntSupplier Inga parametrar, returnerar ett resultat av int-typ.
21	IntToDoubleFunction Accepterar en int typ indata och returnerar ett dubbeltypresultat.
22	IntToLongFunction Accepterar en int-typ indata och returnerar ett resultat av lång typ.
23	IntUnaryOperator Acceptera en parameter av typen int, och returnera värdetypen är också int.
24	LongBinaryOperator Acceptera både parametrar av typen long och returnera värdetyp as long.
25	LongConsumer Acceptera en indataparameter av typen long utan något returvärde.
26	LongFunction<R> Accepterar en långtyp-indataparameter och returnerar ett resultat.
27	Långpredikat R accepterar en lång indataparameter och returnerar ett boolskt resultat.
28	LongSupplier Ingen parameter, returnerar ett resultat av typen lång.
29	LongToDoubleFunction Accepterar en långtypindata och returnerar ett dubbeltypresultat.
30	LongToIntFunction Accepterar en långtyp-indata och returnerar ett resultat av int-typ.
31	LongUnaryOperator Acceptera en parameter av samma typ som lång, och returnera värdet av typen som också är långt.
32	ObjDoubleConsumer<T> Acceptera en objekttyp och en dubbeltyp-inmatningsparameter utan returvärde.
33	ObjIntConsumer<T> Acceptera indataparametrar av typen objekt och typ int utan något returvärde.
34	ObjLongConsumer<T> Accepterar indataparametrar för typ object och type long utan att returnera värden.
35	Predikat<T> Accepterar en indataparameter och returnerar ett boolesk resultat.
36	Leverantör<T> Inga parametrar, returnerar ett resultat.
37	ToDoubleBiFunction<T,U> Accepterar två indataparameterar och returnerar ett dubbeltypresultat
38	TillDubbelfunktion<T> Accepterar en indataparameter och returnerar ett dubbeltypresultat
39	ToIntBiFunction<T,U> Acceptera två indataparametrar och returnera ett resultat av int-typ.
40	ToIntFunction<T> Acceptera en indataparameter och returnera ett resultat av int-typ.
41	ToLongBiFunction<T,U> Acceptera två indataparametrar och returnera ett långtypresultat.
42	ToLongFunction<T> Acceptera en indataparameter och returnera ett resultat av lång typ.
43	UnaryOperator<T> Acceptera en parameter av typ T och returnera värdet av typ T.

JagDet funktionella gränssnittet i Java är delegaten i .NET/C#, passera metoden som en parameter, enligt följande:

Introduktion till C#-delegater (delegat, Handling, Func, predikat)
https://www.itsvse.com/thread-4658-1-1.html

Funktion Vanliga metoder och metoder och metoder

//将Function对象应用到输入的参数上，然后返回计算结果。
R applic(T t);

Även om Funktion< T, R > ta emot T-objekt, returnera R-objekt och endast ett mottagande och returnera objekt, men kombinerat med tupler kan flera inkommande och returnerande värden uppnås, hänse til:

Användningen av tupler i Java
https://www.itsvse.com/thread-10055-1-1.html

Exempel 1: Passa två värden och summera dem

Du kan använda plain writing och lambda-uttryck, koden är följande:

Inloggningen är synlig.

Exempel 2:

och Sedan metoden

Inloggningen är synlig.

Kompone-metoden

Inloggningen är synlig.

Fullständig kod

Inloggningen är synlig.

Resultat i returen

Inloggningen är synlig.

(Slut)

Flygande fisk · Publicerad på 2021-09-19 19:34:22

Java tittade också, även om det inte används

[Källa] Detaljerad förklaring av vanliga funktionella gränssnitt (delegater) i Java

Relaterade inlägg

Avsnitt som ses