Discussion :

[BainE]

bonjour,

j'ai plusieurs classes qui héritent d'une interface :

Code :

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

1
2
3
4
5
6
7
 
public interface DataXml {
 
	public abstract Element toXmlElement();
 
	public abstract DataXml toData( Element racine ) throws DataConversionException;
}

exemple de classe :

Code :

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

1
2
3
4
 
public class Action implements DataXml {
...
}

Dans une autre classe j'ai une fonction :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public class EchangeXml {
 
	private int versionProtocole;
	private List< DataXml > lstData;
 
        public List<DataXml> getLstData() {
		return lstData;
	}
 
	public void setLstData(List<DataXml> lstData) {
		this.lstData = lstData;
	}

et le problème arrive, je ne peux pas utiliser mon setLstData avec une List<Action>.
Je ne comprends pas pourquoi, mon Action est bien un DataXml
Je fais quoi de mal ?

[thelvin]

Hello,

du fait de l'existence de ton interface DataXml, il est possible qu'en plus de ta classe Action, il existe une autre classe Bidule :

Code :

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

1
2
3
4
5
public class Bidule implements DataXml {
 
  /* ... */
 
}

Maintenant, étudions ce qu'on peut faire avec une variable de type List<DataXml> :

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
 
List<DataXml> list = echange.getLstData();
Action action = new Action(/* ... */);
Bidule bidule = new Bidule(/* ... */);
DataXml data1 = new DataXml() {
  @Override
  public Element toXmlElement() { return null; }
 
  @Override
  public DataXml toData(Element racine) { return null; }
};
 
DataXml data2 = list.get(0); // compile très bien
list.add(action); // compile très bien
list.add(bidule); // compile très bien
list.add(data1); // compile très bien

Parfait n'est-ce pas ?

Et maintenant voyons ce qu'on peut faire avec une variable de type List<Action> :

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
 
List<Action> list = new ArrayList<>();
Action action = new Action(/* ... */);
Bidule bidule = new Bidule(/* ... */);
DataXml data1 = new DataXml() {
  @Override
  public Element toXmlElement() { return null; }
 
  @Override
  public DataXml toData(Element racine) { return null; }
};
 
DataXml data2 = list.get(0); // compile très bien
list.add(action); // compile très bien
list.add(bidule); // ERREUR! Compile pas
list.add(data1); // ERREUR! Compile pas

Clairement, ça ne marche pas.

Conclusion : il y a des choses qu'une List<DataXml> peut faire, et qu'une List<Action> ne peut pas faire.

Par conséquent, on ne peut pas assigner une List<Action> à une List<DataXml>. Il existe des choses qu'on pourrait avoir besoin de faire, et qu'elle ne peut pas faire. Assignation refusée donc.

Solution

Il est probable que tu n'aies aucune envie d'ajouter de nouveaux éléments après la construction de ta liste de DataXml. Par conséquent tu n'as pas envie de pouvoir faire les lignes suivantes :

Code :

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

1
2
3
list.add(action); // pas besoin
list.add(bidule); // pas besoin
list.add(data1); // pas besoin

Mais tu veux par contre pouvoir faire la ligne suivante ou équivalent :

Code :

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

DataXml data2 = list.get(0);

Dans ce cas, la liste dont tu as besoin, n'a pas besoin d'être de type List<DataXml>. Tu peux te contenter de demander une List<? extends DataXml>.

Ça veut dire "Liste dont on ne sait pas ce qu'elle contient, mais on sait que ce qu'elle contient est sous-type de DataXml".

Comme on ne sait pas ce que contient cette List, on ne peut pas y ajouter le moindre élément : on ne sait pas si cet élément est compatible avec ce qu'elle contient. Mais ce n'est pas grave, car tu n'as pas besoin d'y ajouter des éléments. Tu as juste besoin de lire les éléments qu'elle contient, et de savoir qu'ils sont sous-type de DataXml.

Et tout ça, une List<Action> peut le faire. On peut donc assigner une List<Action> à une variable de type List<? extends DataXml>.

Le code doit donc être :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class EchangeXml {
 
  private int versionProtocole;
  private List<? extends DataXml> lstData;
 
  public List<? extends DataXml> getLstData() {
    return lstData;
  }
 
  public void setLstData(List<? extends DataXml> lstData) {
    this.lstData = lstData;
  }
 
}