Un bref tutoriel sur les génériques Java

Les génériques sont une fonctionnalité introduite dans Java SE 5.0 Au fil des années depuis l'apparition de cette fonctionnalité du langage, je pense que presque tous les programmeurs Java en ont non seulement entendu parler, mais l'ont également utilisé. Il existe de nombreux tutoriels sur les génériques Java, gratuits et payants. Les meilleurs manuels que j'ai rencontrés sont :

• The Java Tutorial

• Java Generics and Collections, de Maurice Naftalin et Philip Wadler

• Effective Java Chinese Edition (2e édition), par Joshua Bloch.

Bien qu'il y ait tellement d'informations riches, parfois j'ai l'impression qu'il y en a beaucoup des programmeurs ne comprennent toujours pas bien la fonction et la signification des génériques Java. C'est pourquoi j'ai voulu résumer sous la forme la plus simple les choses les plus élémentaires qu'un programmeur doit savoir sur les génériques Java.

La motivation derrière les génériques Java

La façon la plus simple de comprendre les génériques Java est de les considérer comme une syntaxe pratique qui peut vous éviter certaines opérations de conversion (casting) de type Java :

List<Apple> box = ...;
Apple apple = box.get(0);

Le code ci-dessus lui-même s'exprime très clairement : box est une liste contenant des objets Apple. La méthode get renvoie une instance d'objet Apple et aucune conversion de type n'est requise dans ce processus. Sans génériques, le code ci-dessus doit être écrit comme ceci :

List box = ...;
Apple apple = (Apple) box.get(0);

De toute évidence, le principal avantage des génériques est de permettre au compilateur de conserver les informations de type des paramètres, d'effectuer une vérification de type et effectuer des opérations de conversion de type : le compilateur garantit que ces conversions de type sont sans erreur.

Plutôt que de compter sur les programmeurs pour mémoriser les types d'objets et effectuer des conversions de types - ce qui peut provoquer des échecs d'exécution du programme difficiles à déboguer et à résoudre, les compilateurs peuvent aider les programmeurs à forcer un grand nombre de vérifications de type pour trouver des erreurs.

La composition des génériques

La composition des génériques introduit la notion de variable de type. Selon la spécification du langage Java, une variable de type est un identifiant sans restriction qui se produit dans les situations suivantes :

• Déclaration de classe générique

• Interface générique déclaration

• Déclaration de méthode générique

• Déclaration de constructeur générique

Classes et interfaces génériques

Si une classe ou une interface possède une ou plusieurs variables de type, elle est générique. Les variables de type sont délimitées par des crochets angulaires et placées après le nom de la classe ou de l'interface :

public interface List<T> extends Collection<T> {
...
}

En termes simples, le rôle d'une variable de type est comme un paramètre, qui est fourni au compilateur pour le type vérification des informations.

De nombreuses classes de la bibliothèque de classes Java, comme l'ensemble du framework Collection, ont été modifiées pour être génériques. Par exemple, l'interface List que nous avons utilisée dans le premier morceau de code ci-dessus est une classe générique. Dans ce code, box est un objet List, qui est une instance d'une implémentation de classe de l'interface List avec une variable de type Apple. Le compilateur utilise ce paramètre de variable de type pour effectuer automatiquement une conversion de type lorsque la méthode get est appelée et renvoie un objet Apple.

En fait, cette nouvelle balise générique, ou la méthode get dans cette interface List ressemble à ceci :

T get(int index);

méthode get Ce qui est réellement retourné est un objet de type T, qui est la variable de type dans la déclaration List

Les méthodes et constructeurs génériques (Constructeur)

sont très similaires, si un ou plusieurs types sont déclarés sur la méthode et le constructeur Variables, ils peut aussi être générique.

public static <t> T getFirst(List<T> list)

Cette méthode acceptera un paramètre de type List et renverra un objet de type T.

Exemple

Vous pouvez soit utiliser les classes génériques fournies dans la bibliothèque de classes Java, soit utiliser vos propres classes génériques.

Écriture de données sécurisées...

Le code suivant est un exemple. Nous créons une instance List

List<String> str = new ArrayList<String>();
str.add("Hello ");
str.add("World.");

str.add(1); // 不能编译

String myString = str.get(0);

for (Iterator<String> iter = str.iterator(); iter.hasNext();) {
String s = iter.next();
System.out.print(s);
}

for (String s: str) {
System.out.print(s);
}

List<Integer> ints = new ArrayList<Integer>();
ints.add(0);
ints.add(1);
int sum = 0;
for (int i : ints) {
sum += i;
}

Apple a = ...;
Fruit f = a;

List<Apple> apples = ...;
List<Fruit> fruits = apples;

List<Apple> apples;
List<Fruit> fruits = ...;
apples = fruits;

List<Apple> apples = ...;
List<Fruit> fruits = apples;
fruits.add(new Strawberry());

Apple[] apples = ...;
Fruit[] fruits = apples;

Apple[] apples = new Apple[1];
Fruit[] fruits = apples;
fruits[0] = new Strawberry();

void sort(Object[] o);

List<Apple> apples = new ArrayList<Apple>();
List<? extends Fruit> fruits = apples;

List<Fruit> fruits = new ArrayList<Fruit>();
List<? super Apple> = fruits;

Apple[] apples = new Apple[1];
Fruit[] fruits = apples;
fruits[0] = new Strawberry();

List<Apple> apples = new ArrayList<Apple>();
List<? extends Fruit> fruits = apples;
fruits.add(new Strawberry());

fruits.add(new Fruit());

Fruit get = fruits.get(0);

List<Fruit> fruits = new ArrayList<Fruit>();
List<? super Apple> = fruits;

fruits.add(new Apple());
fruits.add(new GreenApple());

fruits.add(new Fruit());
fruits.add(new Object());