Java tillhandahåller en ny funktion som kallas metodreferens i Java 8. Metodreferens används för att referera till metod för funktionellt gränssnitt. Det är kompakt och lätt form av lambda uttryck. Varje gång du använder lambdauttryck för att bara hänvisa till en metod, kan du ersätta ditt lambdauttryck med metodreferens. I den här handledningen förklarar vi metodreferenskonceptet i detalj.

Typer av metodreferenser

Det finns följande typer av metodreferenser i java:

1. Hänvisning till en statisk metod.
2. Referens till en instansmetod.
3. Referens till en konstruktör.

1) Hänvisning till en statisk metod

Du kan hänvisa till statisk metod definierad i klassen. Följande är syntaxen och exemplet som beskriver processen att hänvisa till statisk metod i Java.

Syntax

jpa vs viloläge

 ContainingClass::staticMethodName 

Exempel 1

I följande exempel har vi definierat ett funktionellt gränssnitt och hänvisar en statisk metod till dess funktionella metod say().

 interface Sayable{ void say(); } public class MethodReference { public static void saySomething(){ System.out.println('Hello, this is static method.'); } public static void main(String[] args) { // Referring static method Sayable sayable = MethodReference::saySomething; // Calling interface method sayable.say(); } } 

Produktion:

 Hello, this is static method. 

Exempel 2

I följande exempel använder vi fördefinierat funktionellt gränssnitt Runnable to refer static method.

 public class MethodReference2 { public static void ThreadStatus(){ System.out.println('Thread is running...'); } public static void main(String[] args) { Thread t2=new Thread(MethodReference2::ThreadStatus); t2.start(); } } 

Produktion:

 Thread is running... 

Exempel 3

Du kan också använda fördefinierade funktionella gränssnitt för att referera metoder. I följande exempel använder vi BiFunction-gränssnittet och använder it's application()-metoden.

 import java.util.function.BiFunction; class Arithmetic{ public static int add(int a, int b){ return a+b; } } public class MethodReference3 { public static void main(String[] args) { BiFunctionadder = Arithmetic::add; int result = adder.apply(10, 20); System.out.println(result); } } 

Produktion:

 30 

Exempel 4

Du kan också åsidosätta statiska metoder genom att hänvisa metoder. I följande exempel har vi definierat och överbelastat tre add-metoder.

 import java.util.function.BiFunction; class Arithmetic{ public static int add(int a, int b){ return a+b; } public static float add(int a, float b){ return a+b; } public static float add(float a, float b){ return a+b; } } public class MethodReference4 { public static void main(String[] args) { BiFunctionadder1 = Arithmetic::add; BiFunctionadder2 = Arithmetic::add; BiFunctionadder3 = Arithmetic::add; int result1 = adder1.apply(10, 20); float result2 = adder2.apply(10, 20.0f); float result3 = adder3.apply(10.0f, 20.0f); System.out.println(result1); System.out.println(result2); System.out.println(result3); } } 

Produktion:

 30 30.0 30.0 

2) Referens till en instansmetod

som statiska metoder kan du också referera till instansmetoder. I följande exempel beskriver vi processen att hänvisa till instansmetoden.

Syntax

 containingObject::instanceMethodName 

Exempel 1

I följande exempel hänvisar vi till icke-statiska metoder. Du kan referera metoder efter klassobjekt och anonymt objekt.

 interface Sayable{ void say(); } public class InstanceMethodReference { public void saySomething(){ System.out.println('Hello, this is non-static method.'); } public static void main(String[] args) { InstanceMethodReference methodReference = new InstanceMethodReference(); // Creating object // Referring non-static method using reference Sayable sayable = methodReference::saySomething; // Calling interface method sayable.say(); // Referring non-static method using anonymous object Sayable sayable2 = new InstanceMethodReference()::saySomething; // You can use anonymous object also // Calling interface method sayable2.say(); } } 

Produktion:

 Hello, this is non-static method. Hello, this is non-static method. 

Exempel 2

I följande exempel hänvisar vi till instansmetoden (icke-statisk). Körbart gränssnitt innehåller bara en abstrakt metod. Så vi kan använda det som ett funktionellt gränssnitt.

 public class InstanceMethodReference2 { public void printnMsg(){ System.out.println('Hello, this is instance method'); } public static void main(String[] args) { Thread t2=new Thread(new InstanceMethodReference2()::printnMsg); t2.start(); } } 

Produktion:

 Hello, this is instance method 

Exempel 3

I följande exempel använder vi BiFunction-gränssnittet. Det är ett fördefinierat gränssnitt och innehåller en funktionell metod apply(). Här hänvisar vi till lägga till metod för att tillämpa metod.

 import java.util.function.BiFunction; class Arithmetic{ public int add(int a, int b){ return a+b; } } public class InstanceMethodReference3 { public static void main(String[] args) { BiFunctionadder = new Arithmetic()::add; int result = adder.apply(10, 20); System.out.println(result); } } 

Produktion:

 30 

3) Referens till en konstruktör

Du kan hänvisa en konstruktör genom att använda det nya nyckelordet. Här hänvisar vi konstruktör med hjälp av funktionellt gränssnitt.

Syntax

 ClassName::new 

Exempel

 interface Messageable{ Message getMessage(String msg); } class Message{ Message(String msg){ System.out.print(msg); } } public class ConstructorReference { public static void main(String[] args) { Messageable hello = Message::new; hello.getMessage('Hello'); } } 

Produktion:

 Hello