Bonjour les gens,

je vais poser une question qui a sans doute déjà été discutée, mais je n'arrive pas à trouver les bons mots-clefs pour faire ma recherche.

Je voudrais votre avis sur l'utilisation des Generics pour /typer/ des objets. Je m'explique. J'ai des méthodes qui utilisent des objets de même classe mais qui n'ont rien à voir. Je veux éviter d'utiliser un objet pour un autre, et cela, en leur donnant un type différent. Par exemple, j'ai deux objets de classe A, je voudrais les spécifier de classe B extends A pour le premier et C extends A pour le second, de telle manière que je ne puisse plus utiliser l'un à la place de l'autre (impossible d'ajouter des objets C dans une liste de B). En pratique, B et C sont tous les deux la même classe A.

Exemple plus complet : Je souhaite tester la bisimilarité entre deux graphes. Chaque graphe a un ensemble de nœuds, et je veux leur donner un type différent parce qu'à chaque fois que je manipule un nœud, je sais de quel graphe il provient. D'où le bout de code qui suit : je type les graphes par N1 extends Node et N2 extends Node et je ne peux plus confondre un nœud de type N1 avec un nœud de type N2. Ça donne ça :

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
import java.util.*;
 
// Classe permettant de tester la bisimilarite entre deux graphes
public class Bisimil {
 
    public boolean areBisimilar(Graph g1, Graph g2) {
	return new InternalBisim<Node,Node>(g1,g2).bisim();
    }
 
    // Classe interne pour cacher le typage des nodes a un utilisateur externe.
    class InternalBisim<N1 extends Node, N2 extends Node> {
	private TypedGraph<N1> _g1;
	private TypedGraph<N2> _g2;
 
	public InternalBisim(Graph g1, Graph g2) {
            // les noeuds de g1 sont de type N1 et ceux de g2 de type N2
	    _g1 = new TypedGraph<N1>(g1);
	    _g2 = new TypedGraph<N2>(g2);
	}
 
	public boolean bisim() {
	    // Test standard de bisimilarite. 
	    // Puisque les nodes de g1 et les nodes de g2 sont types, 
	    // il est impossible de les confondre.
 
	    return true;
	}
    }
 
}
 
// Typage de graphe : 
// permet de specifier un pseudo-type pour les noeuds de ce graphe.
class TypedGraph<N extends Node> {
    private Graph _g;
 
    TypedGraph(Graph g) {
	_g = g;
    }
 
    @SuppressWarnings("unchecked")
    public Set<N> getNodes() {
	return (Set<N>)_g.getNodes();
    }
 
    @SuppressWarnings("unchecked")
    public Set<N> succ(N n) {
	return (Set<N>)_g.succ(n);
    }
 
    @SuppressWarnings("unchecked")
    public Set<N> init() {
	return (Set<N>)_g.init();
    }
 
    public boolean isInit(N n) {
	return _g.isInit(n);
    }
 
    // etc.
}
D'où mes questions :
1- Pensez-vous que cette technique rende le code plus facile à lire ?
2- Existe-il une autre manière de faire qui ait les mêmes avantages ?

Merci.