Discussion :

[Shivan]

bonjour,

Il y a quelque chose que je n'arrive pas à comprendre au niveau des types génériques de java 5 et particulièrement du wildcard.

quelle est la différence entre :
void functionName(List<T> myList)
et
void functionName(List<?> myList)
et
void functionName(List<E> myList)


Merci

[adiGuba]

Salut,


Il n'y a pas vraiment de différence en List<T> ou List<E>... ou plutôt il faudrait voir la déclaration de la classes Generics pour dire s'il y a une différence.

Lorsqu'on utilise des Generics, par conventions le nom des types paramétrés ne prend qu'une seule lettre. On utilise souvent T pou "Type", mais E est également utilisé dans l'API de collections pour désigner un "Element". Dans les Map on utilise K,V pour "Key,Value"... bref tout ceci est au choix du développeur : ce n'est qu'un nom



Pour le wildcard List<?>, cela signifie en fait que tu n'as pas besoin de connaitre le type paramétré de l'objet, ce qui te permet de faire un code générique sans te soucier du typage...


a++

[Shivan]

Merci adiGuba pour ta réponse.

Cependant je n'ai toujours pas compris la différence entre List<T> et list<?>.
Dans les 2 cas je peux remplacer T ou ? par n'importe quel type (List<Integer> par exemple). Donc est ce que déclarer un type générique avec T ou ? à les même effet ?

[verbose]

Non, ce n'est pas du tout la même chose. Si tu utilises le wildcard, tu ne peux pas faire référence au type paramétré. En revanche, dans le cas de List<T>, tu peux avoir ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
public class List<T> {
	private T attribut;

	public T getAttribut() {
		return attribut;
	}

	public void setAttribut(T var) {
		attribut = var;
	}
}

[adiGuba]

Non : avec T tu connais plus ou moins le type à un moment donné.
Avec ? tu ignores tout du type.


Prend l'exemple de cette classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class MaClasse<T> {
 
	public void method1( List<T> list ) {
		for (T t : list) {
			System.out.println(t);
		}
	}
 
	public void method2( List<?> list ) {
		for (Object o : list) {
			System.out.println(o);
		}
	}
}

Les deux méthodes font la même chose, mais une est "fortement" typé (<T>) et l'autre est plus générique (<?>).

Ainsi si tu tentes de compiler ce code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
	MaClasse<String> maClasse = new MaClasse<String>();
	List<String> strings = Arrays.asList("un", "deux", "trois");
	List<Integer> integers = Arrays.asList(1, 2, 3);
 
	maClasse.method1(strings);
	maClasse.method1(integers); // Erreur de compilation
	maClasse.method2(strings);
	maClasse.method2(integers);

Tu n'apercevras que tu as une erreur de compilation sur le second appel de method1(), car les types ne correspondent pas, alors qu'il n'y a aucun problème avec method2().

En contrepartie, le <?> (qui signifie implicitement <? extends Object>) te limite dans tes actions et tu ne peux pas utiliser d'objet prenant un type paramétré en paramètre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
List<?> list = ...;
list.add( "Hello" ); // Interdit car tu ne connais pas le paramétrage exact

En fait le <?> est utilisé pour du code générique où tu n'as pas besoin de vérifier ni d'utiliser un type précis.


a++

[Shivan]

Merci pour vos réponses. C'est maintenant plus clair dans mon esprit.