Java bietet in Java 8 eine neue Funktion namens Methodenreferenz. Methodenreferenz wird verwendet, um auf Methoden der Funktionsschnittstelle zu verweisen. Es ist eine kompakte und einfache Form des Lambda-Ausdrucks. Jedes Mal, wenn Sie einen Lambda-Ausdruck verwenden, um nur auf eine Methode zu verweisen, können Sie Ihren Lambda-Ausdruck durch einen Methodenverweis ersetzen. In diesem Tutorial erklären wir das Konzept der Methodenreferenz im Detail.

Arten von Methodenreferenzen

In Java gibt es folgende Arten von Methodenreferenzen:

1. Verweis auf eine statische Methode.
2. Verweis auf eine Instanzmethode.
3. Verweis auf einen Konstruktor.

1) Verweis auf eine statische Methode

Sie können auf die in der Klasse definierte statische Methode verweisen. Im Folgenden finden Sie die Syntax und das Beispiel, die den Prozess der Referenzierung einer statischen Methode in Java beschreiben.

Syntax

 ContainingClass::staticMethodName 

Beispiel 1

Im folgenden Beispiel haben wir eine funktionale Schnittstelle definiert und eine statische Methode auf ihre funktionale Methode say() verwiesen.

 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(); } } 

Ausgabe:

 Hello, this is static method. 

Beispiel 2

Im folgenden Beispiel verwenden wir die vordefinierte Funktionsschnittstelle Runnable, um auf eine statische Methode zu verweisen.

 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(); } } 

Ausgabe:

 Thread is running... 

Beispiel 3

Sie können auch vordefinierte Funktionsschnittstellen verwenden, um auf Methoden zu verweisen. Im folgenden Beispiel verwenden wir die BiFunction-Schnittstelle und deren apply()-Methode.

 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); } } 

Ausgabe:

 30 

Beispiel 4

Sie können statische Methoden auch überschreiben, indem Sie auf Methoden verweisen. Im folgenden Beispiel haben wir drei Add-Methoden definiert und überladen.

 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); } } 

Ausgabe:

 30 30.0 30.0 

2) Verweis auf eine Instanzmethode

Wie statische Methoden können Sie auch auf Instanzmethoden verweisen. Im folgenden Beispiel beschreiben wir den Prozess der Referenzierung der Instanzmethode.

Syntax

 containingObject::instanceMethodName 

Beispiel 1

Im folgenden Beispiel beziehen wir uns auf nicht statische Methoden. Sie können Methoden nach Klassenobjekt und anonymem Objekt referenzieren.

 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(); } } 

Ausgabe:

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

Beispiel 2

Im folgenden Beispiel beziehen wir uns auf eine Instanzmethode (nicht statisch). Die ausführbare Schnittstelle enthält nur eine abstrakte Methode. Wir können es also als funktionale Schnittstelle verwenden.

 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(); } } 

Ausgabe:

 Hello, this is instance method 

Beispiel 3

Im folgenden Beispiel verwenden wir die BiFunction-Schnittstelle. Es handelt sich um eine vordefinierte Schnittstelle und enthält eine funktionale Methode apply(). Hier beziehen wir uns auf „Methode hinzufügen“ und „Methode anwenden“.

 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); } } 

Ausgabe:

 30 

3) Verweis auf einen Konstruktor

Sie können auf einen Konstruktor verweisen, indem Sie das Schlüsselwort new verwenden. Hier beziehen wir uns auf den Konstruktor mithilfe einer funktionalen Schnittstelle.

Syntax

 ClassName::new 

Beispiel

 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'); } } 

Ausgabe:

 Hello