2 classes similaire et pas de classe mere?!
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:
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:
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:
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:
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...
