Sécurité des types et génériques génériques : comprendre le modificateur interdit

Lorsque vous travaillez avec des collections génériques en Java, le concept de génériques génériques peut introduire certains des limitations qui peuvent sembler contre-intuitives à première vue. Un bon exemple est l'incapacité d'ajouter des valeurs à une collection Java avec un type générique générique.

Considérez l'extrait de code suivant :

List extends Parent> list = ...;
Parent p = factory.get(); // returns concrete implementation
list.set(0, p); // fails here: set(int, ? extends Parent) cannot be applied to (int, Parent)

Pourquoi ce code ne parvient-il pas à se compiler ? La réponse réside dans les mécanismes de sécurité inhérents qui sont appliqués par les génériques génériques.

Le principe de récupération sans restriction et d'ajout restreint

Le type générique générique, noté ? étend Parent, représente une liste d'éléments qui sont des descendants de l'interface Parent. Bien qu'elle permette une récupération sans restriction de ces éléments, la sécurité des types dicte des restrictions sur l'ajout de valeurs à la collection.

Si le code était autorisé à se compiler, il permettrait l'affectation d'une instance Parent à un élément de la liste. Cependant, cette action pourrait potentiellement rompre la sécurité des types.

Considérez le scénario suivant :

List childList = new ArrayList();
childList.add(new Child());

List extends Parent> parentList = childList;
parentList.set(0, new Parent());

Child child = childList.get(0); // No! It's not a child! Type safety is broken...

Dans ce scénario, une liste d'objets enfants est convertie en une liste de ? » étend Parent. L'affectation ultérieure d'une instance Parent au premier élément de la liste viole la sécurité des types, car la liste résultante contient un élément qui n'est pas une instance Enfant valide.

Garantir la sécurité des types immuables

En interdisant l'ajout de valeurs aux collections génériques génériques, Java applique la sécurité des types immuables. Cela garantit que les éléments de la liste respectent toujours les contraintes imposées par leur type déclaré.

En l'absence de cette restriction, la sécurité du type serait compromise, entraînant des erreurs potentielles et un comportement inattendu.