2 classes similaire et pas de classe mere?!

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

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, 22h44

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, 01h03

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, 11h30

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, 13h28

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, 14h12

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** · 19/09/2009, 23h18

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é !

**Alain Defrance** · 20/09/2009, 13h31

Bonjour,

Tente avec :

Code :

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

1
2
3
4
public abstract class ListeChainee<T> {
    protected ElementListe<T> premier;
    // ...
}

et

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public class ElementListe<T> {
    //variables
    private ElementListe<T> suivant;
    private T valeur;
 
    // constructeurs
    public ElementListe(T valeur) {
        this.valeur = valeur;
        this.suivant = null;
    }
 
}

**eilijah** · 20/09/2009, 15h30

En fait le probleme c'est qu'il y a 2 types d'objet generique dans la liste et 2 dans l'element :

Code :

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

1
2
3
4
5
6
7
8
 
LC<>{ // Liste chainée de type générique
  EL<> premier; // élément de liste de type générique
  ajouterAuDebut(T<> objet1){ // objet de l'élément de type générique
    EL oldElt = premier;
    premier = new EL(objet1, oldElt);
  }
}

Code :

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

1
2
3
4
5
 
EL<>{ // élément de liste de type générique
  T<> objet1; // objet de l'élément de type générique
  EL<> suivant; // élément de liste de type générique
}

du coup comme on peut transmettre un seul parametre generique dans la declaration de la classe je vois pas comment ca peut se faire.

Dans ton code :

Code :

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

1
2
3
4
public abstract class ListeChainee<T> {
    protected ElementListe<T> premier;
    // ...
}

"protected ElementListe<T> premier; "
signifie que ElementListe ne peut contenir que des objets de type ElementListe<T> non ?
Du coup je ne peux pas mettre de contenu dedans? genre un int? et encore moins accéder à ce type?

**tchize_** · 20/09/2009, 15h41

du coup comme on peut transmettre un seul parametre generique dans la declaration de la classe je vois pas comment ca peut se faire.

Tu peux transmettre autant de paramètres que tu veux, il suffit de les séparer par des virgules.

**eilijah** · 20/09/2009, 15h48

un truc dans ce gout la? :

Code :

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

1
2
3
4
5
6
7
8
 
LC<T1<T1,T2>>{ // Liste chainée de type générique
  T1 premier; // élément de liste de type générique
  ajouterAuDebut(T2 objet1){ // objet de l'élément de type générique
    EL oldElt = premier;
    premier = new EL(objet1, oldElt);
  }
}

Code :

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

1
2
3
4
5
 
EL<T1,T2>{ // élément de liste de type générique
  T2 objet1; // objet de l'élément de type générique
  EL<T1,T2> suivant; // élément de liste de type générique
}

hum je nage completement je crois lol.

**tchize_** · 20/09/2009, 18h57

pourquoi t'as besoin de lusieurs type, a priori ta liste chainée stocke un type bien précis. donc un seul paramètre générique suffit.

**eilijah** · 20/09/2009, 20h50

bah non j'ai 3 classes de liste :
-listeChainéeJoueur qui stock des ElementListeJoueur qui stock des objets Joueur
-listeChainéeCarte qui stock des ElementListeCarte qui stock des objets Carte
-listeChainée qui stock des ElementListe qui stock des int

Les 3 classes de listes ont des methodes specifiques mais le gros est la copie conforme des autres sauf qu'elles n'utilise pas les meme objets (Joueur/elementListeJoueur, Carte/EklementListeCarte, int/ElementListe).

**tchize_** · 20/09/2009, 21h42

je ne vois qu'un parametre dans l'histoire: joueur / carte / int.

T'as deux possibilités. Soit faire une ListeChainee<T> ou T est le type stocké dans chaque élément. ou faire une ListeChainee<T extends ElementList<?>>

**eilijah** · 20/09/2009, 22h43

Soit faire une ListeChainee<T> ou T est le type stocké dans chaque élément

Euh alors en fait si tu fais ca veut dire qu'il y'a des objets de type T dans ListeChainee? j'avais compris que ca voulait dire TOUS les objets de ListeChainee DOIVENT désormais etre de type T.

Du coup j'ai fait ca :

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
public abstract class LC<Obj extends Object,Elt extends EL<Obj>> {
 
	/* variables d'instance */
 
	protected EL<Obj> premier;
 
	/* accesseurs de variable d'instance*/
 
	public EL<Obj> getPremier() {
		return premier;
	}
 
	/* accesseurs aux elements */
 
	protected EL<Obj> getDernierElement() {
		EL<Obj> dernier= premier;
		while (dernier.getSuivant() != null) {
			dernier= dernier.getSuivant();
		}
		return dernier;
	}
 
 
	/* modificateurs */
 
	public void concatener(LC<Obj,Elt> list) {
		if (this.estVide()) {
			this.premier= list.premier;
		} else {
			EL<Obj> dernier= getDernierElement();
			dernier.setSuivant(list.getPremier());
		}
	}
 
	public abstract void ajouterAuDebut(Obj obj);
 
	public abstract void ajouterALaFin(Obj obj);
...
}

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
 
// classe abstraite d'element de liste
public abstract class EL<T extends Object> {
 
	/* attributs */
 
	protected T contenu;
	protected EL<T> suivant;
 
	/* constructeurs */
 
	public EL(T contenu) {
		this.contenu = contenu;
		suivant = null;
	}
 
	public EL(T contenu, EL<T> suivant) {
		this.contenu = contenu;
		this.suivant = suivant;
	}
 
	/* accesseurs */
 
	public EL<T> getSuivant() {
		return suivant;
	}
 
	public void setSuivant(EL<T> suivant) {
		this.suivant = suivant;
	}
 
	public T getContenu() {
		return contenu;
	}
 
	public void setContenu(T contenu) {
		this.contenu = contenu;
	}
 
}

J'ai pas testé mais eclipse me sort pas d'erreurs .
Mais en effet si je comprend bien ce que tu dis on peut faire plus simple!

Merci pour ton aide en tous les cas!

**eilijah** · 20/09/2009, 22h50

Ok en fait j'ai juste eut a changer :

Code :

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

public abstract class LC<Obj extends Object,Elt extends EL<Obj>> {

par

Code :

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

public abstract class LC<Obj extends Object> {

et les arguments dans les classes étendues, ca l'air ok , merci !

**tchize_** · 20/09/2009, 22h55

dans ton premier code, remplace a la pluspart des endroits EL<Obj> par Elt, ca permet de garder le typage. Sinont dans ton code Elt n'est pas utiliser il serait donc inutile

**eilijah** · 21/09/2009, 00h16

Ouaip en fait ca vient du fait que je pensais devoir indiquer tous les type de la classe, du coup vu que je tenais a indiquer le Obj pour avoir un Elt dynamique j'ai ajouté

Code :

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

Elt extends EL<Obj>

faute de pouvoir faire :

Code :

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

1
2
 
public abstract class LC<Obj extends Object,EL<Obj>> {

en étandant Elt ca passe.. bien que je l'utilise pas aprés ! enfin toute facon maintenant y'a plus que

Code :

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

public abstract class LC<Obj extends Object> {

Bonne nuit!

2 classes similaire et pas de classe mere?!

Langage Java

Discussions similaires

Partager

Partager