2 classes similaire et pas de classe mere?!

**eilijah** · 29/05/2009, 19h45

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...

**Djakisback** · 29/05/2009, 23h44

Effectivement tu dois pouvoir faire ça plus générique.
Tu peux stocker des Object et caster ou utiliser un template : http://www-igm.univ-mlv.fr/~forax/ja...emplate/paper/

**tchize_** · 30/05/2009, 02h03

Utilise des interfaces/sous classes et, éventuellement, des générics. On aurait queeque chose dans ce gout là:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public abstract class ElementListe<T extends Object> {
    //variables
    private ElementListe<T> suivant;
    private T valeur;
 
    // constructeurs
    public ElementListe(T valeur) {
        this.joueur = valeur;
        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
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public abstract class ListeChainee<T extends ElementList<?>> {
    protected T premier;
    public boolean estVide() {
        return premier == null;
    }
    
    public int getLongueur() {
        int longueur= 0;
        T elt= getPremier();
        while (elt != null) {
            longueur++;
            elt= elt.getSuivant();
        }
        return longueur;
    }
    
    // Contenu de la liste / get
    public T getPremier() {
        return premier;
    }
    
    private T getDernierElement() {
        T dernier= premier;
        while (dernier.getSuivant() != null) {
            dernier= dernier.getSuivant();
        }
        return dernier;
    }
       // .....
}

Et finalement, pour faire les vraies listes:

Code :

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

1
2
3
public class ElementListeJoueurs extends ElementList<Joueur>{}
public class ListeJoueuer extends ListChainee<ElementListeJoueur>{}

**Alain Defrance** · 05/06/2009, 12h30

Envoyé par Djakisback

Effectivement tu dois pouvoir faire ça plus générique.
Tu peux stocker des Object et caster ou utiliser un template : http://www-igm.univ-mlv.fr/~forax/ja...emplate/paper/

Le cast est quelque chose de dangereux, il doit être évité autant que possible car nous nous exposons au java.lang.ClassCastException. Quant aux templates, le terme en Java est generics.

**tchize_** · 05/06/2009, 14h28

Envoyé par Alain Defrance

Le cast est quelque chose de dangereux, il doit être évité autant que possible car nous nous exposons au java.lang.ClassCastException.

Première nouvelle

. Le ClassCastException résulte surtout d'erreur de logique dans le code. L'opérateur cast existe pour une bonne raison, s'en servir. Certe les generics ont leur utilité pour garantir que les cast seront correct, mais tout n'est pas non plus resolvable en generics

**Alain Defrance** · 05/06/2009, 15h12

Ce que je voulais dire par la, c'est que lorsque c'est possible, il vaut mieux les éviter. Le cast n'est pas suicidaire non plus, surtout qu'on peut être sûr de lui grâce à instanceof, mais j'ai tendence à l'éviter dès que possible.

Pour moi c'est une très mauvaise pratique de typer des paramètres et valeurs de retours en Object pour rendre générique une méthode.

**eilijah** · 20/09/2009, 00h18

Salut,

je me permet de relancer la discussion parce que j'ai pas pu vraiment creusé cette histoire à l'epoque. (j'ai fait simple et répititif faute de temps !).

Donc là je tente de refaire tout ca bien et je bloque.

Prenons ce code:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 public abstract class ElementListeJoueur {
    //variables
    private ElementListeJoueur suivant;
    private Joueur valeur;
 
    // constructeurs
    public ElementListe(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
14
 
 public abstract class ListeChaineeJoueur {
    protected ElementListeJoueur premier;
 
	public void ajouterALaFin(Joueur v) {
		if (estVide()) {
			premier= new ElementListeJoueur(v);
		} else {
			ElementListeJoueur dernier = getDernierElement();
			dernier.setSuivant(new ElementListeJoueur(v));
		}
	}
...
}

Le code que tchize_ me donne me permet de faire le principale mais comment gérer l'argument de ajouterALaFin() ? car forcément pour ListeChaineeJoueur ca sera un objet "Joueur" mais pour ListeChaineeCarte ca sera un objet "Cartes".

j'ai tenté un truc du genre :

Code :

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

1
2
 
  public abstract class ListeChainee<ElementList<T>> {}

mais il n' a pas aimé !

2 classes similaire et pas de classe mere?!

Langage Java

Vue hybride

Discussions similaires

Partager

Partager