Opérateur Double Colon(::) en Java
En Java, on peut utiliser l’opérateur double-point (::) pour appeler une méthode en s’y référant à l’aide de son nom de classe.
Nous pouvons également le faire en utilisant les expressions lambda. La seule différence que nous trouvons ici est que nous pouvons directement référencer la méthode par son nom tout en utilisant l’opérateur ::.
Alors que, lorsque nous utilisons des expressions lambda, nous avons besoin d’un délégué à la méthode que nous devons appeler. Cet article traitera de l’utilisation de l’opérateur :: en Java.
Il existe différents endroits où nous pouvons utiliser l’opérateur :: en Java. Nous pouvons utiliser l’opérateur :: pour référencer les méthodes.
Ainsi, nous pouvons extraire des méthodes statiques à partir de classes ou d’objets en utilisant le ::. On peut même utiliser l’opérateur :: pour les constructeurs.
De plus, lorsqu’on nous donne un flux d’entrée, nous pouvons utiliser l’opérateur :: pour imprimer les éléments du flux d’entrée.
Quand et comment utiliser l’opérateur Double Colon (::) en Java
Nous pouvons utiliser l’opérateur :: tout en traitant des méthodes statiques, des méthodes d’instance, des super méthodes, une méthode d’instance d’un objet arbitraire d’un type particulier et même des constructeurs de classe.
Examinons chacune des approches une par une.
Tout en traitant avec des méthodes statiques
Nous pouvons utiliser l’opérateur :: en Java lorsqu’il s’agit de méthodes statiques. Pour obtenir une référence à la méthode statique d’une classe, nous allons d’abord écrire le nom de la classe suivi de l’opérateur ::, puis nous allons écrire le nom de la méthode.
Regardons la syntaxe de cette approche :
Syntaxe:
(ClassName::methodName)
Regardons maintenant le code ci-dessous pour comprendre comment cela fonctionne.
import java.util.*;
public class Main {
static void staticFunction(String s) // static function which is called using :: operator
{
System.out.println(s);
}
public static void main(String args[]) {
List<String> list = new ArrayList<String>();
list.add("This");
list.add("is");
list.add("an");
list.add("example");
list.forEach(Main::staticFunction);
}
}
Production :
This
is
an
example
Lors de la gestion des méthodes d’instance
Nous pouvons également utiliser l’opérateur :: en Java lorsqu’il s’agit de méthodes d’instance.
Pour obtenir une référence à la méthode d’instance d’une classe, nous allons d’abord écrire l’objet de la classe. Ensuite, nous mettrons l’opérateur ::, et enfin, nous écrirons le nom de la méthode.
Voyons la syntaxe de cette approche.
Syntaxe:
(ObjectOfTheClass::methodName)
Regardons maintenant le code ci-dessous pour comprendre comment cela fonctionne.
import java.util.*;
public class Main {
void instanceFunction(String s) // function which is called using :: operator
{
System.out.println(s);
}
public static void main(String args[]) {
List<String> list = new ArrayList<String>();
list.add("This");
list.add("is");
list.add("an");
list.add("example");
Main object = new Main();
list.forEach(object::instanceFunction);
}
}
Production :
This
is
an
example
Tout en traitant avec des super méthodes
Nous pouvons également utiliser l’opérateur :: en Java lorsqu’il s’agit de super méthodes.
Pour référencer la méthode super d’une classe, nous allons d’abord écrire le mot-clé super. Ensuite, nous mettrons l’opérateur ::, et enfin, nous écrirons le nom de la méthode.
Voyons la syntaxe de cette approche.
Syntaxe:
(super::methodName)
Regardons maintenant le code ci-dessous pour comprendre comment cela fonctionne.
// Java code to show use of double colon operator for super methods
import java.util.*;
import java.util.function.*;
class SuperClass {
// super function to be called
String printFunction(String s) {
return ("This is Print function output from the SuperClass: " + s);
}
}
public class Main extends SuperClass {
// instance method to override super method
@Override
String printFunction(String s) {
// call the super method
// using double colon operator
Function<String, String> func = super::printFunction;
String newValue = func.apply(s);
System.out.println(newValue);
return newValue;
}
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("This");
list.add("is");
list.add("an");
list.add("example");
Main object = new Main();
list.forEach(object::printFunction);
}
}
Production :
This is Print function output from the SuperClass: This
This is Print function output from the SuperClass: is
This is Print function output from the SuperClass: an
This is Print function output from the SuperClass: example
Lors du traitement de la méthode d’instance d’un objet arbitraire d’un type particulier
Nous pouvons également utiliser l’opérateur :: en Java lorsqu’il s’agit de la méthode d’instance d’un objet arbitraire d’un type particulier.
Pour référencer la méthode d’instance d’un objet arbitraire d’un type spécifique, nous allons d’abord écrire le nom de la classe. Ensuite, nous mettrons l’opérateur ::, et enfin, nous écrirons le nom de la méthode.
Voyons la syntaxe de cette approche.
Syntaxe:
(ClassName::methodName)
Regardons maintenant le code ci-dessous pour comprendre comment cela fonctionne.
// Java code to show the use of double colon operator for instance method of arbitrary type
import java.util.*;
class Test {
String s = null;
Test(String s) {
this.s = s;
}
// instance function to be called
void instanceFunction() {
System.out.println(this.s);
}
}
public class Main {
public static void main(String[] args) {
List<Test> list = new ArrayList<Test>();
list.add(new Test("This"));
list.add(new Test("is"));
list.add(new Test("an"));
list.add(new Test("example"));
list.forEach(Test::instanceFunction); // call the instance method using double colon operator
}
}
Production :
This
is
an
example
Tout en traitant avec le constructeur de classe
Nous pouvons également utiliser l’opérateur :: en Java lorsqu’il s’agit du constructeur de classe.
Pour obtenir une référence au constructeur de la classe, nous allons d’abord écrire le nom de la classe. Ensuite, nous mettrons l’opérateur ::, et enfin, nous écrirons new qui appellera le constructeur de cette classe particulière.
Voyons la syntaxe de cette approche.
Syntaxe:
(ClassName::new)
Regardons maintenant le code ci-dessous pour comprendre comment cela fonctionne.
// Java code to show the use of double colon operator for class constructor
import java.util.*;
public class Main {
public Main(String s) {
System.out.println(s);
}
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("This");
list.add("is");
list.add("an");
list.add("example");
list.forEach(Main::new); // call the instance method using double colon operator
}
}
Production :
This
is
an
example
Conclusion
Dans cet article, nous avons examiné cinq endroits et utilisé l’opérateur double-point (::) en Java.
Toutes les techniques ont leur signification, et vous pouvez appliquer l’opérateur :: chaque fois que vous rencontrez l’une des situations ci-dessus. Soyez prudent avec la syntaxe, car une mauvaise utilisation peut entraîner une situation erronée.