Discussion :

[Sharcoux]

Bonjour,

J'ai un petit soucis avec asList :

Code :

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

1
2
3
4
5
6
    public static void main(String[] args) {
        List<Class<? extends ClassMere>> L = Arrays.asList(ClassFille.class,ClassFille.class);
    }
 
    public static class ClassMere {}
    public static class ClassFille extends ClassMere {}

J'obtiens :

Code :

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

1
2
3
4
Exception in thread "main" java.lang.RuntimeException: Uncompilable source code - incompatible types
  required: java.util.List<java.lang.Class<? extends test.Main.ClassMere>>
  found:    java.util.List<java.lang.Class<test.Main.ClassFille>>
        at test.Main.main(Main.java:41)

[kox2ee]

Bonjour,
Dans l'écriture :

List<Class<? extends ClassMere>> L = Arrays.asList(ClassFille.class,ClassFille.class);

ClassFille hérite de ClassMere donc ClassFille est une ClassMere et le ? est respecté.
C'est Ok :

Class<? extends ClassMere> m=ClassFille.class;

Par contre, une liste de ClassFille n'est pas une Liste de ClassMere. List<ClassFille> n'est pas Compatible avec List<ClassMere>.
Il n'y a pas de covariance sur les generics, et tu dois l'introduire explicitement à nouveau avec le joker ?

List<? extends Class<? extends ClassMere>> L = Arrays.asList(ClassFille.class,ClassFille.class);

[Sharcoux]

Wow... Alors là j'ai du mal. Effectivement, ça a l'air de marcher, mais pourquoi ?

List<? extends Class> Ca veut pas dire une liste d'objets qui héritent de Class ?

D'autre part, regardez le code suivant quand j'ai plusieurs classes filles :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
    public static void main(String[] args) {
        List<Class<? extends ClassMere>> L1 = Arrays.asList(ClassFille1.class,ClassFille2.class);//Pas d'erreur
        List<Class<? extends ClassMere>> L2 = Arrays.asList(ClassFille1.class,ClassFille1.class);//Erreur
 
    }
 
    public static class ClassMere {}
    public static class ClassFille1 extends ClassMere {}
    public static class ClassFille2 extends ClassMere {}

Une explication ?

[rg77140]

Bonjour,

Code :

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

Arrays.asList(ClassFille1.class,ClassFille1.class);

renvoie :

Code :

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

List<Class<ClassFille1>>

Tu ne peux pas associé List<Class<ClassFille1>> à ça List<Class<? extends ClassMere>>, ce n'est pas la même chose. La première dit que tu as une liste qui accepte que des ClassFille1, et toi tu dit que tu as une liste qui accepte n'importe classe fille de ClassMere.

De toute façon tu ne peux pas effectuer d'opérations sur la liste retournée par un Arrays.asList. Cette fonction te renvoie une liste dont les méthodes add, remove, etc... te throw une UnsupportedOperationException. Donc soit tu ne souhaites pas faire de add, remove, ... et à ce moment là tu peux typer comme le compilateur te le demande en List<Class<ClassFille1>>, soit tu souhaites ajouter des éléments à ta liste de façon dynamique et à ce moment là tu dois faire :

Code :

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

1
2
3
List<Class<? extends ClassMere>> liste = new ArrayList<Class<? extends ClassMere>>();
liste.add(ClassFille1.class);
liste.add(ClassFille1.class);

Romain.

[thelvin]

Sinon il y a juste Arrays.<Class<? extends ClassMere>>asList(ClassFille.class,ClassFille.class); mais ça commence à être assez lourdingue.

[hwoarang]

Code :

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

1
2
3
4
5
6
 
    public static void main(String[] args) {
        List<Class<? extends ClassMere>> L1 = Arrays.asList(ClassFille1.class,ClassFille2.class);//Pas d'erreur
        List<Class<? extends ClassMere>> L2 = Arrays.asList(ClassFille1.class,ClassFille1.class);//Erreur
 
    }

Une explication ?

Pour comprendre, il faut regarder la signature de asList : public static <T> List<T> asList(T... a)On voit que le type de List renvoyé dépend des parametres passés à la fonction. Dans le cas ou on passe plusieurs objets de meme type, on va se retrouver une liste du type des objets passés en parametre. En revanche, si on passe des objets de type différent, asList renvoie une liste qui étend le premier pere commun. Si on reprend tes exemples, quand tu passes 2 fois ClassFille1.class, le plus proche pere commun est ClassFille1 donc asList renvoie List<Class<ClassFille1>> qui est incompatible avec List<Class<? extends ClassMere>>. En revanche, quand tu passes ClassFille1.class,ClassFille2.class, le plus proche pere commun est ClassMere donc asList renvoie List<Class<? extends ClassMere>>.

[Sharcoux]

D'accord, d'accord. C'est plus clair comme ça.

Mais alors, quid de la réponse de kox2ee :

Code :

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

List<? extends Class<? extends ClassMere>> L = Arrays.asList(ClassFille.class,ClassFille.class);

En particulier le ? extends Class