Java Diamond Operator :simplifiez les génériques dans Java 7+

Opérateur Java Diamond

L'opérateur Diamond a été introduit dans Java 7 pour rendre le code plus lisible pour les génériques. Un générique est un type d’argument. En utilisant le générique, nous pouvons transmettre n'importe quel type d'objet à traiter par les méthodes de classe. Par exemple, si nous créons une liste de chaînes avant Java 7, nous devons alors utiliser la syntaxe suivante pour instancier une liste de chaînes avec un objet ArrayList.

List<String> listOfStrings = new ArrayList<String>();

À partir de Java 7, nous pouvons utiliser l'opérateur diamant pour simplifier la syntaxe ci-dessus comme suit -

List<String> listOfStrings = new ArrayList<>();

Mais il ne pouvait pas être utilisé avec les classes internes anonymes. Par exemple, nous ne pouvons pas omettre le type d'objet de l'opérateur diamant dans la syntaxe ci-dessous antérieure à Java 9.

Handler<Integer> intHandler = new Handler<Integer>(1) {
 @Override
 public void handle() {
 System.out.println(content);
 }
};

Opérateur Diamond en classe anonyme

Dans Java 9, l'opérateur diamant peut également être utilisé avec une classe anonyme pour simplifier le code et améliorer la lisibilité.

Handler<Integer> intHandler = new Handler<>(1) {
 @Override
 public void handle() {
 System.out.println(content);
 }
};

Opérateur Diamond dans Java 7, Java 8

Dans l'exemple ci-dessous, nous avons créé des classes anonymes pour un gestionnaire de classe abstraite acceptant un argument générique et transmettant le type d'objet lors de la création de la classe anonyme car nous devons transmettre l'argument de type sinon le programme ne sera pas compilé.

Exemple

public class Tester {
 public static void main(String[] args) {
 // create an Anonymous class to handle 1
 // Here we need to pass Type arguments in diamond operator 
 // before Java 9 otherwise compiler will complain error
 Handler<Integer> intHandler = new Handler<Integer>(1) {
 @Override
 public void handle() {
 System.out.println(content);
 }
 };
 intHandler.handle();
 // create an Anonymous class to handle 2 
 Handler<? extends Number> intHandler1 = new Handler<Number>(2) {
 @Override
 public void handle() {
 System.out.println(content);
 }
 };
 intHandler1.handle();
 Handler<?> handler = new Handler<Object>("test") {
 @Override
 public void handle() {
 System.out.println(content);
 }
 };
 handler.handle(); 
 } 
}
abstract class Handler<T> {
 public T content;
 public Handler(T content) {
 this.content = content; 
 }
 
 abstract void handle();
}

Sortie

Compilons et exécutons le programme ci-dessus, cela produira le résultat suivant -

1
2
Test

Opérateur Diamond à partir de Java 9

Avec Java 9, nous pouvons utiliser l'opérateur <> avec une classe anonyme comme indiqué ci-dessous.

Exemple

Dans l'exemple ci-dessous, nous avons créé des classes anonymes pour un gestionnaire de classe abstraite acceptant un argument générique mais sans le type d'objet lors de la création de la classe anonyme car nous n'avons pas besoin de transmettre l'argument de type. Le compilateur déduit le type lui-même.

public class Tester {
 public static void main(String[] args) {
 // create an Anonymous class to handle 1
 // Here we do not need to pass Type arguments in diamond operator 
 // as Java 9 compiler can infer the type automatically
 Handler<Integer> intHandler = new Handler<>(1) {
 @Override
 public void handle() {
 System.out.println(content);
 }
 };
 intHandler.handle();
 Handler<? extends Number> intHandler1 = new Handler<>(2) {
 @Override
 public void handle() {
 System.out.println(content);
 }
 };
 intHandler1.handle();
 Handler<?> handler = new Handler<>("test") {
 @Override
 public void handle() {
 System.out.println(content);
 }
 };
 handler.handle(); 
 } 
}
abstract class Handler<T> {
 public T content;
 public Handler(T content) {
 this.content = content; 
 }
 
 abstract void handle();
}

Sortie

Compilons et exécutons le programme ci-dessus, cela produira le résultat suivant -

1
2
Test