TOC

Guide de l’opérateur Diamond en Java

Guide de l'opérateur Diamond en Java

1. Vue d'ensemble

Dans cet article, nous allons examiner lesdiamond operator in Java and how generics and the Collections API influenced its evolution.

2. Types bruts

Prior to Java 1.5, the Collections API supported only raw types - il n'y avait aucun moyen pour les arguments de type d'être paramétrés lors de la construction d'une collection: 

List cars = new ArrayList();
cars.add(new Object());
cars.add("car");
cars.add(new Integer(1));

Cela a permis d'ajouter n'importe quel type etled to potential casting exceptions at runtime.

3. Génériques

Dans Java 1.5, les génériques ont été introduits -which allowed us to parameterize the type arguments for classes, y compris ceux de l'API Collections - lors de la déclaration et de la construction d'objets: 

List cars = new ArrayList();

À ce stade, nous devonsspecify the parameterized type in the constructor, ce qui peut être quelque peu illisible: 

Map>>> cars
 = new HashMap>>>();

La raison de cette approche est queraw types still exist for the sake of backward compatibility, donc le compilateur doit faire la différence entre ces types bruts et génériques: 

List generics = new ArrayList();
List raws = new ArrayList();

Même si le compilateur nous permet encore d'utiliser des types bruts dans le constructeur, il nous envoie un message d'avertissement: 

ArrayList is a raw type. References to generic type ArrayList should be parameterized

4. Opérateur diamant

L'opérateur diamant - introduit dans Java 1.7 -adds type inference and reduces the verbosity in the assignments – when using generics: 

List cars = new ArrayList<>();

La fonction d'inférence de type du compilateur Java 1.7determines the most suitable constructor declaration that matches the invocation.

Considérez l'interface et la hiérarchie de classes suivantes pour travailler avec des véhicules et des moteurs: 

public interface Engine { }
public class Diesel implements Engine { }
public interface Vehicle { }
public class Car implements Vehicle { }

Créons une nouvelle instance deCar à l’aide de l’opérateur losange: 

Car myCar = new Car<>();

En interne, le compilateur sait queDiesel implémente l'interfaceEngine et est ensuite capable de déterminer un constructeur approprié en déduisant le type.

5. Conclusion

En termes simples, l’opérateur diamond ajoute la fonctionnalité d’inférence de type au compilateur et réduit la verbosité dans les tâches introduites avec les génériques.

Quelques exemples de ce tutoriel peuvent être trouvéson the GitHub project, alors n'hésitez pas à le télécharger et à jouer avec.

Related