Java fournit une nouvelle fonctionnalité appelée référence de méthode dans Java 8. La référence de méthode est utilisée pour faire référence à la méthode de l'interface fonctionnelle. Il s’agit d’une forme compacte et simple d’expression lambda. Chaque fois que vous utilisez une expression lambda pour simplement faire référence à une méthode, vous pouvez remplacer votre expression lambda par une référence de méthode. Dans ce didacticiel, nous expliquons en détail le concept de référence de méthode.

table de vérité de l'additionneur complet

Types de références de méthodes

Il existe les types suivants de références de méthodes en Java :

1. Référence à une méthode statique.
2. Référence à une méthode d'instance.
3. Référence à un constructeur.

1) Référence à une méthode statique

Vous pouvez vous référer à la méthode statique définie dans la classe. Voici la syntaxe et l'exemple qui décrivent le processus de référence à une méthode statique en Java.

Syntaxe

 ContainingClass::staticMethodName 

Exemple 1

Dans l'exemple suivant, nous avons défini une interface fonctionnelle et référencé une méthode statique à sa méthode fonctionnelle 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(); } } 

Sortir:

 Hello, this is static method. 

Exemple 2

Dans l'exemple suivant, nous utilisons l'interface fonctionnelle prédéfinie Runnable pour faire référence à une méthode statique.

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

Sortir:

lire à partir d'un fichier csv en java

 Thread is running... 

Exemple 3

Vous pouvez également utiliser une interface fonctionnelle prédéfinie pour référencer des méthodes. Dans l'exemple suivant, nous utilisons l'interface BiFunction et sa méthode apply().

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

Sortir:

 30 

Exemple 4

Vous pouvez également remplacer les méthodes statiques en faisant référence à des méthodes. Dans l'exemple suivant, nous avons défini et surchargé trois méthodes add.

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

Sortir:

 30 30.0 30.0 

2) Référence à une méthode d'instance

comme les méthodes statiques, vous pouvez également faire référence à des méthodes d’instance. Dans l'exemple suivant, nous décrivons le processus de référence à la méthode d'instance.

Syntaxe

 containingObject::instanceMethodName 

Exemple 1

Dans l'exemple suivant, nous faisons référence à des méthodes non statiques. Vous pouvez référencer des méthodes par objet de classe et par objet anonyme.

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

Sortir:

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

Exemple 2

Dans l'exemple suivant, nous faisons référence à la méthode d'instance (non statique). L'interface exécutable ne contient qu'une seule méthode abstraite. Nous pouvons donc l'utiliser comme interface fonctionnelle.

chaînage avant

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

Sortir:

 Hello, this is instance method 

Exemple 3

Dans l'exemple suivant, nous utilisons l'interface BiFunction. Il s'agit d'une interface prédéfinie et contient une méthode fonctionnelle apply(). Ici, nous faisons référence à l’ajout d’une méthode pour appliquer la méthode.

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

Sortir:

 30 

3) Référence à un constructeur

Vous pouvez référencer un constructeur en utilisant le nouveau mot-clé. Ici, nous faisons référence au constructeur à l’aide d’une interface fonctionnelle.

Syntaxe

 ClassName::new 

Exemple

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

Sortir:

 Hello