Discussion :

[Mako 5013]

Bonjour,

Dans le cadre de petits projets personnels, j'ai l'architecture suivante : un premier projet, sur lequel vont s'appuyer d'autres projets par la suite. J'ai donc une sorte de "base" dont vont étendre par la suite les autres projets.

Pour le moment, j'ai par exemple 3 projets (au sens Eclipse) : la base, projet1 et projet2. Ces deux derniers incluent donc la base en tant que jar, et beaucoup de leurs classes héritent de classes génériques de la base.

Maintenant que le cadre est donné, voici le genre de soucis auxquels je suis confronté. Dans la base, j'ai une interface et une classe abstraite comme suite :

Code projet_Base :

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
 
public interface MonInterface {
 
     public void maMethode(MaClasseTest _maClasse);
     // Test Generics : public <T extends MaClasseTest> void maMethode(T _maClasse);
 
}
 
public abstract class MaClasseAbstraite implements MonInterface {
 
     // Definition de methodes generiques qui serviront a tous les projets
     // se basant sur la base
 
}
 
public class MaClasseTest {
 
    // Le contenu est sans importance ici
 
}

Puis, dans mon projet1 par exemple, j'ai ceci :

Code projet_1 :

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
 
 
public class MaClasseTestProjet1 extends MaClasseTest {
 
    // Le contenu est sans importance ici
 
}
 
public class MaClasse extends MaClasseAbstraite {
 
     @Override
     public void maMethode(MaClasseTest _maClasse) {
    // Avec Generics : public void maMethode(MaClasseTestProjet1 _maClasse) {
    // Problème : ne compile pas...
 
     }
}

Ce que je voudrais, c'est que dans mon projet1, je travaille uniquement avec MaClasseTestProjet1, et plus du tout avec MaClasseTest. Pour ce faire, je voulais utiliser les Generics dans mon projet de base, mais je dois mal m'y prendre (cf. commentaires ci-dessus). A l'heure actuelle, le code (celui non-commenté ici) fonctionne, mais m'oblige parfois à faire des cast dans tous les sens, ce que je ne trouve pas très heureux.

J'espère avoir été assez clair dans mes explications.

Mako.

[adiGuba]

Salut,



Il ne faut pas placer le Generics sur la méthode, car cela s'appliquera alors uniquement sur la méthode et non pas sur la classe entière.

Dans ton cas je définirais l'interface comme ceci :

Code :

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

1
2
3
interface MonInterface<T extends MaClasseTest> {
     public void maMethode(T maClasse);
}

Pour la classe abstraite on conserve le même typeage Generics :

Code :

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

1
2
3
abstract class MaClasseAbstraite<T extends MaClasseTest> implements MonInterface<T> {
	// ...
}{

Ensuite tu as en gros 2 solutions :

1. Perdre le typeage Generics, en le spécifiant en dur dans l'héritage :

Code :

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

1
2
3
4
5
6
7
class MaClasse extends MaClasseAbstraite<MaClasseTestProjet1> {
 
     @Override
     public void maMethode(MaClasseTestProjet1 maClasse) {
    	 // ...
     }
}

Du coup lors des redéfinitions tu peux remplacer le "T" par le type en dur.



2. Spécifier plus précisément le typeage Generics, en utilisant ta nouvelle classe à la place de la classe de base :

Code :

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

1
2
3
4
5
6
7
class MaClasse<T extends MaClasseTestProjet1> extends MaClasseAbstraite<T> {
 
    @Override
    public void maMethode(T maClasse) {
   	 // ...
    }
}

Ce qui laisse la porte ouverte pour de nouvelle classes filles



a++

[Mako 5013]

Bonjour,

Merci pour la réponse.

Je m'étais déjà orienté vers ta première solution (a priori, il ne devrait pas y avoir de classes filles par la suite... Mais on ne sait jamais...). J'avais toutefois trouvé cela assez lourd pour deux raisons :

- Tout d'abord, j'ai ici pris un exemple simple, mais en réalité, je me retrouverais avec quelque chose du genre (solution 2) class MaClasse<T1 extends MaClasse1, T2 extends MaClasse2, T3 extends MaClasse3> extends MaClasseAbstraite<T1, T2, T3>, ce que je trouve assez laid (à tord ?) en soi ;
- Ensuite, la classe concernée (MaClasse dans l'exemple ci-dessus) est gérée par un singleton, ce qui, couplé à la remarque ci-dessus devient vraiment très très lourd à l'écriture (du genre : MaClasse<MaClasse1, MaClasse2, MaClasse3>.getInstance.maMethode(_maClasse1);) ;

Y aurait-il une autre façon de faire ? Ou bien un moyen de contourner ces "lourdeurs" ?

Mako.