Listes paramétrées et conversions

Version imprimable

Bonjour,

J'ai un problème de cast avec mes listes paramétrées. Voici un exemple permettant d'illustrer ce que je veux faire, ça sera mieux qu'une dizaine de lignes de texte :P

Code:

1
2
3
 
public interface TestModel {
}

Code:

1
2
3
 
public interface TestMutableModel extends TestModel {
}

Code:

1
2
3
4
5
 
public class Test implements TestMutableModel {
    public Test() {
    }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
public class Main {
    public static void main(String args[]) {
        // Ok ca marche.
        TestModel tm;
        TestMutableModel tmm = new Test();
        tm = tmm;
 
        // KO Ca ne marche pas!
        List<TestModel> ltm;
        List<TestMutableModel> ltmm = new ArrayList<TestMutableModel>();
        ltm = ltmm; // Impossible.
        ltm = (List<TestModel>) ltmm; // Impossible aussi évidemment.
    }
}

Je ne sais pas comment faire, sans me passer des generics. Quelqu'un aurait une solution élégante ?

Merci :)

12/09/2007, 10h25
adiGuba
Salut,

C'est normal que ce ne soit pas possible, car si ce code était autorisé tu pourrais faire ceci par exemple :
Code:

1 2 3 4 5 List<TestMutableModel> ltmm = new ArrayList<TestMutableModel>(); List<TestModel> ltm; = (List<TestModel>) ltmm; // Impossible ltm.add( new MonAutreClasseQuiImplementeTestModel() );
Bref tu ajoutes dans ltm une classe qui implémente TestModel mais pas TestMutableModel. Or comme ltm et ltmm représente la même liste cela veut dire que tu ajoutes dans ltmm un objet qui n'implémente pas TestMutableModel :arrow: tu casses la protection des generics !

Pour pallier à cela tu as deux solutions :
1. Créer une copie de la liste contenant les mêmes éléments :
  Code:
  
  1 2 List<TestMutableModel> ltmm = new ArrayList<TestMutableModel>(); List<TestModel> ltm = new ArrayList<TestModel>(ltmm);
  :arrow: Si tu modifies ltm cela n'aura aucun impact sur ltmm...
2. Ou utiliser les wilcards qui permettent de limiter l'utilisation de la classe :
  Code:
  
  1 2 List<TestMutableModel> ltmm = new ArrayList<TestMutableModel>(); List<? extends TestModel> ltm = ltmm;
  Ici ltm et ltmm représente toujours la même liste en mémoire, mais ltm est limité et tu ne pourras pas utiliser toutes ses méthodes. Ainsi toutes les méthodes qui attendent un type paramétré en paramètre sont inutilisable puisque le type paramétré exact est inconnu.
  Bref tu ne pourras pas faire :
  
  Code:
  
  ltm.add( "...n'importe quoi..." );
  
  Par contre tu pourras toujours utiliser les méthode qui n'utilises pas de type paramétré ou qui se contente de le renvoyer :
  
  Code:
  
  TestModel tm = ltm.get(0);
Plus d'info : Présentation de Java 5.0 - Les Generics

a++

Je te remercie, pour ces explications. La solutution 2 ne convient pas car j'ai besoin d'accéder aux méthode définies dans l'interface mutable.
La solution 1 serait donc à adopter mais je suis pas sûr que ça soit bien ce que j'ai fait. Voici un exmple simplifié plus concret de ce que je veux faire :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
public class Chapter implements ChapterMutableModel {
 
    private List<ExerciseMutableModel> exercises;
 
    public Chapter() {
        this.exercises = new ArrayList<ExerciseMutableModel>();
    }
 
    public Chapter(List<ExerciseMutableModel> exercises) {
        this.exercises = exercises;
    }
 
    public void setExercises(List<ExerciseMutableModel> exercises) {
        this.exercises = exercises;
    }
 
    public List<ExerciseModel> getExercises() {
        return Collections.unmodifiableList(new ArrayList<ExerciseModel>(this.exercises));
    }
}

12/09/2007, 15h10
adiGuba
Citation:

Envoyé par TheSeb

Je te remercie, pour ces explications. La solutution 2 ne convient pas car j'ai besoin d'accéder aux méthode définies dans l'interface mutable.

Heu... comme tu renvois une liste de ExerciseModel donc tu ne pourras pas utiliser les méthodes de l'interface mutable...
De plus tu renvoi une liste non modifiable donc la protections des wilcards est un p'tit plus à la compilation (cela t'interdira d'appeler les méthodes add()).

Pour moi tu pourrais très bien faire ceci :
Code:

1 2 3 4 public List<? extends ExerciseModel> getExercises() { return Collections.unmodifiableList(this.exercises); }
a++
12/09/2007, 17h00
TheSeb

Citation:

Envoyé par adiGuba

Heu... comme tu renvois une liste de ExerciseModel donc tu ne pourras pas utiliser les méthodes de l'interface mutable...
De plus tu renvoi une liste non modifiable donc la protections des wilcards est un p'tit plus à la compilation (cela t'interdira d'appeler les méthodes add()).

Ah oui mince, c'est pile poil ce qu'il me faut dans ma méthode getExercises.
J'avais dans la tête l'initialison de ma variable comme ca au début : private List<? extends ExerciseModel> exercises; ... bref je me demande à quoi je pense des fois :) Je vérifierai quand même que tout ca fonctionne comme je le voulais ce soir chez moi.

Merci.