Embrouillé par l'opérateur "wildcard"

Bonjour,

J'ai toujours compris par : List<?extends B> list que list acceptera des elements de type héritant de B. (On descends dans l'arbre des classes)

Et List<? super B> list que list acceptera des elements de type dont B hérite (On remonte dans l'arbre des classes).

Alors pourquoi ce qui suit ne compile pas??

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

class A{}   class B extends A{}   class C extends B{}   public class Test {   public static void main(String[] args) {   List<? extends B> list = new ArrayList<B>(); list.add(new B()); list.add(new C());   List<? super B> list1 = new ArrayList<A>(); list.add(new B()); list.add(new A()); }   }

---

D'autre part à quoi ca sert de définir <? extends B> puisque le polymorphisme permet deja cela.

A l'aide

Salut,

Ce n'est pas tout à fait cela.
Les wildcards permettent de travailler avec des objets paramétrés dont tu ne connais pas le type exact, afin d'écrire un code plus générique.

En effet les types Generics sont fortement typé et donc fortement incompatible. Si B hérite de A, tu as le droit de faire ceci :

Code:

---

1 2	A b = new B(); A[] array = new B[10];

---

Par contre tu n'as pas le droits de faire ceci :

Code:

---

List<A> list = new ArrayList<B>(); // NE COMPILE PAS

---

En effet en cas d'ajout de mauvais éléments dans la liste (par exemple une classe C héritant de A mais pas de B) : tu casses la contrainte de type de la liste ce qui devrait provoquer une exception à l'exécution (alors que l'objectif des Generics est d'éviter cela).

:arrow: Les wildcards interviennent alors afin de proposer une version "diminué" mais un peu plus compatible sous certaines contrainte.


En fait lorsque tu utilises List<? extends A>, tu sais que tu manipules une List paramétrée avec A ou un type héritant, sans connaitre exactement lequel. Du coup tu peux lire les éléments de la liste (tu es sûr qu'ils sont du type A), mais tu ne peux pas ajouter des éléments dans la liste (car tu ne connais pas le type exact qu'il faut ajouter).


Par exemple si tu as une liste déclarée comme ceci :

Code:

---

List<Integer> listIntegers = new ArrayList<Integer>();

---

Tu ne peux pas faire cela :

Code:

---

List<Number> listNumbers = listIntegers; // ERREUR

---

Et donc tu dois passer par les wildcards qui t'empêcheront d'utilsier certaines méthodes afin de conserver la cohérence des types, par exemple :

Code:

---

1 2 3 4

List<? extends Number> listNumbers = listIntegers;   Number value = listNumbers.get(0); // OK listNumbers.add(10); // ERREUR car on ne connait pas le type exact de la liste

---

Les <? super X> c'est pareil dans le sens inverse : tu peux ajouter des éléments mais tu ne connais pas le type réel des éléments à lire...


Je ne sais pas si c'est clair...



a++

Ma propre formulation :

- List<?> : liste de trucs dont on ne sait pas ce que c'est.
-- Fournit des Object, parce que tout objet est un Object
-- N'accepte aucune entrée, parce qu'on ne sait pas ce que ça contient, et donc on ne sait pas ce qu'on peut y mettre.
-- On peut affecter n'importe quel List à un List<?>.

Code:

---

List<?> list = new ArrayList<Date>();

---

- List<? extends A> : liste de trucs dont on ne sait pas ce que c'est, mais qui, au moins, sont A ou sous-classe de A.
-- Fournit des A.
-- N'accepte aucune entrée, parce qu'on ne sait pas ce que ça contient.
-- On peut affecter à List<? extends A> toute List dont on sait que le contenu étend A.

Code:

---

1 2 3 4

List<? extends A> list = new ArrayList<A>(); // Soit B une sous-classe de A... List<? extends B> listB = getListB(); List<? extends A> listA = listB

---

Note : List<?> est un raccourci pour List<? extends Object>

- List<? super A> : liste de trucs dont on ne sait pas ce que c'est, mais en tout cas des trucs auxquels on peut affecter des A.
-- Fournit des Object, parce qu'on ne sait pas ce que ça contient.
-- Accepte des A en entrée.
-- On peut affecter à List<? super A> toute List qui accepte des A en entrée.

Code:

---

1 2 3 4

List<? super A> list = new ArrayList<A>(); // Soit B une sur-classe de A... List<? super B> listB = getListB(); List<? super A> listA = listB

---

- List<A> : liste de A.
-- Fournit des A.
-- Accepte des A en entrée.
-- On ne peut y affecter que des List de A.

Merci,

Maintenant c'est plus clair.