Discussion :

[MrEddy]

Bonjour,


Je ne parviens pas a comprendre comment caster une java.util.List comprenant un type générique vers une liste comprenant un autre type générique mais dans la meme hierarchie de 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
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class Test
{
	public static void main(String[] args)
	{
		List<B> lstB = new ArrayList<B>();
 
		List<A> lstA;
 
		//Erreurs :
		lstA = lstB;
		//Erreurs :
		lstA = (List<A>)lstB;
	}
 
	private class A
	{
		public String getA()
		{
			return "A";
		};
	}
 
	private class B extends A
	{
		public String getB()
		{
			return "B";
		}
	}
}

Est ce que cela peut avoir un rapport avec les déclarations du type List<?> ??

Merci

[jcdentons]

Bonjour,
Il y a un post récent à ce sujet :
http://www.developpez.net/forums/d93.../caster-liste/

[Astartee]

Supposons que l'instruction lstA = lstB; soit acceptée. Alors les références lstA et lstB pointeraient vers la même liste.
La listelstA étant déclarée comme une Liste<A>, tu pourrais y ajouter n'importe quel objet de type A, même s'il ne s'agit pas d'un objet de type B.
Ce qui reviendrait à ajouter un objet de type A (non B) dans lstB (=lstA) alors que lstB est une Liste<B>. Problème.

Voilà pourquoi le compilateur ne peut pas accepter de "caster" en Liste<A> une liste initialement déclarée comme Liste<B>.


EDIT
Si je n'ai pas réussi à être claire, voici le message que j'ai tenté de copier de mémoire : http://www.developpez.net/forums/d93...e/#post5271795

[adiGuba]

Salut,



Ces erreurs sont normales. Sans cela on pourrait faire ceci :

Code :

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

1
2
3
4
5
6
List<B> lstB = new ArrayList<B>();
List<A> lstA = (List<A>)lstB;
 
lstA.add(new A()); // on ajoute un A dans une List<A>
 
B b = lstB.get(0); // on récupère un élément de type B

comme lstA et lstB référence la même liste, on aurait dans les deux cas un objet de type A... alors que lstB ne l'autorise pas...

Bref autoriser cela reviendrait à avoir un code non typesafe, alors que c'est là tout l'intérêt des Generics...




Pour palier à cela il faut utiliser les wildcards pour définir un type partiel :

Code :

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

1
2
	List<B> lstB = new ArrayList<B>();
	List<? extends A> lstA = lstB;

Ici lstA contient des éléments de type A ou enfant, mais dont tu ne connais pas précisément le type. Cela permet de faire des traitements génériques sans risque de problème (tu ne peux pas faire de add() par exemple, puisque tu ne connais pas le type réel à utiliser).


Tu peux également faire l'inverse avec super, mais les cas d'utilisation sont plus rare :

Code :

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

1
2
	List<A> lstA = new ArrayList<A>();
	List<? super B> lstB = lstA;

a++

[MrEddy]

Merci pour toutes ses infos, c'est plus clair.