Discussion :

[Benoit_T]

Bonjour à tous,

Je fais face au problème suivant:

Soit une classe B héritant d'une classe A.

L'exemple suivant "compile":

Code :

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

1
2
3
4
5
6
void test(){
     B b = new B();
     tester(b);
}
 
tester(A a){ }

Par contre, l'exemple suivant ne compile pas:

Code :

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

1
2
3
4
5
6
void test(){
     List<B> listeb  = new ArrayList<B>();
     tester(listeb );
}
 
void tester(List<A> listeA){ }

Logique puisque B hérite de A mais ArrayList<B> n'hérite pas pour autant d'ArrayList<A>

Du coup mon approche à été la suivante:

Code :

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

1
2
3
4
5
6
void test(){
     List<B> listeb = new ArrayList<B>();
     tester(listeb );
}
 
void <G extends A>tester(List<G> listeG){ }

La tout marche, la méthode tester est spécifiée comme prennant en paramètre une liste d'instance de la classe G, héritant de A. Cependant, quid des perfs, une approche aussi générique peut-elle avoir une incidance sur les performance (il s'agit de code très appellé et donc très critique en terme de performances).

Qui plus est je rajoute même une couche d'héritage, mon pattern de code étant similaire à:

Code :

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

1
2
3
4
5
6
class Matching<T>{
...
 
void <G extends T>tester(List<G> listeG, List<Matching<T>> listeMatching)
 
}

Cordialement,
Benoît.

[le y@m's]

Les générics n'ont aucune incidence sur les performances pour la simple et bonne raison que le code généré par le compilateur sera le même derrière à savoir une list d'objet.
Les générics ne sont pas des templates, ils servent uniquement à la compilation mais sont perdus à l'exécution.
Ainsi le code

Code :

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

1
2
3
List<A> list = new ArrayList<A>();
A a = new A();
list.add(a);

est exactement le même que

Code :

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

1
2
3
List list = new ArrayList();
A a = new A();
list.add(a);

à la seule différence que si on essaye de compiler en ajoutant un objet de type B, ça ne compilera pas dans le premier cas. Mais à l'execution c'est la même chose et ce aussi complexe que soit le généric .

[Deaf]

Bonjour,

je ne suis pas sur à 100%, mais j'aurais envie de dire que la généricité n'impacte pas les perf dans la mesure où elle disparaît à l'exécution.

Pour info, dans le cas où tu ne fais que consulter les éléments de ta liste et de les traiter en tant que A, tu peux très bien t'en sortir sans typer ta méthode:

Code :

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

void tester(List<? extends A> listeA){ }

Cette notation possède des limites mais permet une écriture plus souple.
Elle est, à mon sens, plus adaptée quand tu ne souhaites que traiter des A sans plus d'infos.

[le y@m's]

Tu trouveras plus de détails sur les Generics dans cet article