Salut a tous

voila j'ai 2 classes de listes chainées qui ont les mêmes methodes cependant, les 2 valeurs des chainons ne sont pas les meme d'une liste a l'autre :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
 
public class ElementListeJoueurs {
	//variables
	private ElementListeJoueurs suivant;
	private Joueur joueur;
 
	// constructeurs
	public ElementListeJoueurs(Joueur joueur) {
		this.joueur = joueur;
		this.suivant = null;
	}
...
}
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
 
public class ElementListe {
	//variables
	private ElementListe suivant;
	private int valeur;
 
	// constructeurs
	public ElementListe(Int v) {
		this.valeur = v;
		this.suivant = null;
	}
...
}
vous voyez que "suivant" et "valeur" ne sont pas les meme objet dans les 2 classes.

Cependant ces 2 classes sont liées a 2 autres classes ListeIter() et ListeChaineeJoueur() qui sont les liste proprement dites et qui regroupe une dizaine de méthode a la logique similaire :

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
public class ListeIter {
 
	/* Variables */
	protected ElementListe premier;
 
 
	/* Méthodes */
 
	// taille de la liste / about
	public boolean estVide() {
		return premier == null;
	}
 
	public int getLongueur() {
		int longueur= 0;
		ElementListe elt= getPremier();
		while (elt != null) {
			longueur++;
			elt= elt.getSuivant();
		}
		return longueur;
	}
 
	// Contenu de la liste / get
	public ElementListe getPremier() {
		return premier;
	}
 
	private ElementListe getDernierElement() {
		ElementListe dernier= premier;
		while (dernier.getSuivant() != null) {
			dernier= dernier.getSuivant();
		}
		return dernier;
	}
 
	public boolean contient(int v) {
		boolean trouve= false;
		ElementListe elt= getPremier();
		while (! trouve && elt != null) {
			if (elt.getValeur() ==v ) {
				trouve= true;
			} else {
				elt= elt.getSuivant();
			}
		}
		return trouve;
	}
 
	// Ajout à la liste / set 
	public void ajouterAuDebut(int v) {
		ElementListe ancienPremier= premier;
		premier= new ElementListe(v,ancienPremier);
	}
 
	public void ajouterALaFin(int v) {
		if (estVide()) {
			premier= new ElementListe(v);
		} else {
			ElementListe dernier = getDernierElement();
			dernier.setSuivant(new ElementListe(v));
		}
	}
 
	public void concatener(ListeIter l) {
		if (this.estVide()) {
			this.premier= l.premier;
		} else {
			ElementListe dernier= getDernierElement();
			dernier.setSuivant(l.getPremier());
		}
	}
 
	// Suppression d'elements / delete
	public void retirerPremiereOccurrence(int v) {
		if (estVide())
			return;
		if (premier.getValeur() == v) {
			premier= premier.getSuivant();
		} else {
			ElementListe precedent= premier;
			ElementListe elt= premier.getSuivant();
			while (elt != null && elt.getValeur() != v) {
				precedent= elt;
				elt= elt.getSuivant();
			}
			if (elt != null) {
				precedent.setSuivant(elt.getSuivant());
			}
		}		
	}
}
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
public class ListeChaineeJoueurs {
 
	/* Variables */
 
	// premier element de la liste, ne contient aucun Joueur
	private ElementListeJoueurs premier;
 
 
	/* Méthodes */
 
	// taille de la liste / about
	public boolean estVide() {
		return premier == null;
	}
 
	public int getLongueur() {
		int longueur= 0;
		ElementListeJoueurs elt= getPremier();
		while (elt != null) {
			longueur++;
			elt= elt.getSuivant();
		}
		return longueur;
	}
 
	// Contenu de la liste / get
	public ElementListeJoueurs getPremier() {
		return premier;
	}
 
	private ElementListeJoueurs getDernierElement() {
		ElementListeJoueurs dernier= premier;
		while (dernier.getSuivant() != null) {
			dernier= dernier.getSuivant();
		}
		return dernier;
	}	
 
	public boolean contient(Joueur joueur) {
		boolean trouve= false;
		ElementListeJoueurs elt= getPremier();
		while (! trouve && elt != null) {
			if (elt.getValeur() ==joueur ) {
				trouve= true;
			} else {
				elt= elt.getSuivant();
			}
		}
		return trouve;
	}
 
	// Ajout à la liste / set 
	public void ajouterAuDebut(Joueur joueur) {
		ElementListeJoueurs ancienPremier= premier;
		premier= new ElementListeJoueurs(joueur,ancienPremier);
	}
 
	public void ajouterALaFin(Joueur joueur) {
		if (estVide()) {
			premier= new ElementListeJoueurs(joueur);
		} else {
			ElementListeJoueurs dernier = getDernierElement();
			dernier.setSuivant(new ElementListeJoueurs(joueur));
		}
	}
 
	public void concatener(ListeChaineeJoueurs l) {
		if (this.estVide()) {
			this.premier= l.premier;
		} else {
			ElementListeJoueurs dernier= getDernierElement();
			dernier.setSuivant(l.getPremier());
		}
	}
 
	// Suppression d'elements / delete
 
	public void retirerPremiereOccurrence(Joueur joueur) {
		if (estVide())
			return;
		if (premier.getValeur() == joueur) {
			premier= premier.getSuivant();
		} else {
			ElementListeJoueurs precedent= premier;
			ElementListeJoueurs elt= premier.getSuivant();
			while (elt != null && elt.getValeur() != joueur) {
				precedent= elt;
				elt= elt.getSuivant();
			}
			if (elt != null) {
				precedent.setSuivant(elt.getSuivant());
			}
		}		
	}
}
on voit qu'on a les memes logique de méthodes, je voudrais savoir si il y'a un moyen de regrouper toute la logique du code et de reprendre ces classes plus simplement?
un peu comme avec une classer mère et des classes héritées. Mais la je vois pas comment faire a moins de masquer toutes les méthodes.. ce qui sert a rien au finale...