Problème conception classe générique

Version imprimable

12/10/2009, 23h40
scary

Problème conception classe générique

Bonsoir,

Voila j'essaie désespérément de trouver un moyen de concevoir une classe générique de sorte que je veux forcé les deux paramètre à être du même type, je m'explique avec un exemple.

Admettons que j'ai plusieurs espèces d'animaux (vache, taureau, lion, lionne, ...) je voudrais faire une classe générique avec comme contrainte de forcé la paire d'animaux de la même espèce c'est à dire le lion avec la lionne puis le taureau avec la vache et qu'il ne soit pas possible de mettre un lion avec une vache par contre un lion peut aussi allé avec un lion et une vache avec une vache.

J'espère avoir été assé clair avec mon exemple. Merci d'avance :)
13/10/2009, 08h54
professeur shadoko
je n'ai pas tout à fait compris ... tu peux faire simple ou tu peux faire compliqué.
Si c'est vraiment l'emploi des types paramétrés (generics) que tu cherches voici une solution compliquée:
Code:

1 2 3 4 5 6 7 8 9 abstract class AnimalSage<A extends AnimalSage> { public void pacseLes(A lUn, A lAutre) { ..... } } class Bovin extends AnimalSage<Bovin> { }
et maintenant essaye de marier la carpe et le lapin!
C'est quand même hyper-technique et pas pour les apprentis sorcier :alerte:
13/10/2009, 10h22
professeur shadoko
petits commentaires supplémentaires...

ça serait mieux comme ça
Code:

1 2 3 4 5 class AnimalSage<A extends AnimalSage> { public void sePacseAvec(A lAutre) { } }
et bien entendu il faut créer :
Code:

1 2 3 4 5 class Taureau extends Bovin { } class Vache extends Bovin { }
pour pouvoir les apparier ...
remarque: on peut apparier un taureau avec un taureau .... (mais c'était dans les specs initiales non?)
13/10/2009, 12h04
scary

Je n'ai pas vraiment compris ce que vous m'avez montré puisque déjà pour un couple il faut être deux et donc faire une chose du genre:

Code:

public class Test<A, B>{}

Et donc si je comprend bien la généricité il faudrait que pour contraindre mes paramètres A et B à être tout deux de la même catégorie sans ce préocupé du type des paramètres que je donnerais à cette classe il faudrait écrire une chose du genre:

Code:

public class Test<A extends kelkeChose, B extends kelkeChose>{}

Et c'est ce "kelkeChose" que je ne sais pas par quoi le remplacer. Le truc est que je ne vois pas ce que vous essayé de me montrer. Désolé si cela vous paraît bête de ma part.
13/10/2009, 12h13
adiGuba
Salut,

Pourquoi définir deux types paramétré alors que tu n'en veux qu'un ?
Code:

1 2 3 4 5 6 7 public class Test<T>{ public T getA(); public T getB(); }
a++

Tout simplement parce que je veux créer un couple et que pour faire un couple on a besoin de deux entitées. Et aussi pour manipuler les deux entités que je donnerais à ma classe par exemple dans le main je ferais un truc du genre.
Code:

1 2 3 4 5 6 7 Vache v = new Vache (); Taureau t = new Taureau (); Lion l = new Lion (); Lionne ll = new Lionne (); Couple<Taureau, Vache> cp = new Couple<Taureau, Vache> (); // pour préciser que je veux un taureau et une vache Couple<Taureau, Taureau> cp = new Couple<Taureau, Taureau> (); // possible car je ne veux pas me préocupé du sexe Couple<Taureau, Lion> cp = new Couple<Taureau, Lion> (); // que le compilo me dise que cela n'est pas possible
J'espère avoir été mieux compris :)

Citation:

Envoyé par scary

Tout simplement parce que je veux créer un couple et que pour faire un couple on a besoin de deux entitées.

Tu veux deux entités, mais qui ont le même type (i.e. les deux membres du couple doivent être de la même espèce), donc tu utilises un seul paramètre (l'espèce), non ?
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 public class Couple<T> { private T male; private T female; public Couple(T male, T female) { this.male = male; this.female = female; } public T getMale() { return male; } public T getFemale() { return female; } } public static void main(String args[]) { Bovin taureau1 = ...; Bovin taureau2 = ...; Bovin vache = ...; Lion lion = ...; Lion lionne = ...; Couple<Bovin> couple1 = new Couple<Bovin>(taureau1, vache); Couple<Bovin> couple2 = new Couple<Bovin>(taureau2, vache); Couple<Bovin> couple3 = new Couple<Bovin>(taureau1, taureau2); Couple<Lion> couple4 = new Couple<Lion>(lion, lionne); }
Dans ton exemple d'utilisation tu utilises des types différents pour les animaux de sexe mâle ou femelle, ce qui ne me semble pas pertinent. Sinon, les deux entités que tu mets dans ton couple peuvent (et doivent) effectivement être de type différent, et ça semble difficile à gérer : comment sauras-tu que tel type est compatible avec telle autre (i.e. que "Vache" est compatible avec "Taureau" mais pas avec "Lion") ?
Mieux vaut utiliser un type par espèce, et pour gérer le sexe un flag booléen à l'intérieur de la classe :
Code:

1 2 3 4 5 public abstract class Animal { protected boolean isMale; } public class Bovin extends Animal {} public class Lion extends Animal {}
Le jour où tu voudras tester le sexe de tes animaux avant de les apparier, ça sera très simple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public class Couple<T extends Animal> { public Couple(T male, T female) throws SexException { if (!male.isMale || female.isMale) { throw new SexException(); } this.male = male; this.female= female; } }

13/10/2009, 13h26
LittleBean
Je crois que l'idée est d'avoir la signature suivante pour la classe

Code:

public class Couple<T1,T2 extends Animal,T1 implements Sexe,T2 implements Sexe> {

avec des appels de la forme :
Code:

1 2 Couple<Taureau, Mal,Fem> cp = new Couple<Taureau, Mal, Fem> (); Couple<Taureau, Mal,Mal> cp = new Couple<Taureau, Mal, Mal> ();
.... mais je crois pas que ce soit possible à faire :aie:
13/10/2009, 14h27
adiGuba

C'est ta distinction entre la classe "Taureau" et "Vache" qui n'est pas très clair...

Il faudrait une classe commune aux deux...

a++
13/10/2009, 14h31
scary

Ahhh d'accord oui en effet c'est vrai que l'on pouvait le voir comme cela aussi. C'était donc plus un problème de conception que j'avais autant pour moi :)

Par contre je ne comprend pas très bien comment tu fais pour le sexe, le booleen devra être initialisé non ? et la dans ton exemple il ne l'est pas. Il faut donc rajouter un constructeur pour le faire non ?

Sinon c'est que en faisant ça cela marche mais pas à la compilation mais à l'exécution il y a t-il un moyen pour détecter cela dès la compilation ? (c'est à dire que éclipse me mette une petite croix au niveau de la ligne lorsque j'essai avec deux animaux du même sexe).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class AnimalSage<A extends AnimalSage> {
    public Couple<A> sePacseAvec(A lAutre) {
       return new Couple(this, lAutre) ;
  }
}
 
class Bovin extends AnimalSage<Bovin> {}
 
// Taureau et Vache extends Bovin
// 
Vache clarabelle = new Vache() ;
Couple<Bovin> couple = clarabelle.sePacseAvec(new Taureau() ) ; // OK
Couple<AnimalSage> pasClair = clarabelle.sePacseAvec(new Elephant()); // le compilateur te sort!

C'est pourtant bien ça que tu cherches non?(sans discuter du sexe) ...

Citation:

Envoyé par scary

Par contre je ne comprend pas très bien comment tu fais pour le sexe, le booleen devra être initialisé non ? et la dans ton exemple il ne l'est pas. Il faut donc rajouter un constructeur pour le faire non ?

Bien sûr, si tu veux réussir à créer des femelles il va forcément falloir modifier isMale à un moment ou à un autre ;)

Citation:

Envoyé par scary

Sinon c'est que en faisant ça cela marche mais pas à la compilation mais à l'exécution il y a t-il un moyen pour détecter cela dès la compilation ? (c'est à dire que éclipse me mette une petite croix au niveau de la ligne lorsque j'essai avec deux animaux du même sexe).

Si le sexe est déterminé par un flag booléen comme dans ma proposition, non, tu ne vas pas pouvoir détecter les couples homosexuels à la compilation :aie:

Il y a un moment où il faut espérer que le développeur sait ce qu'il fait et qu'il n'essaie pas d'apparier des animaux du même sexe s'il n'est pas censé le faire.

Mais bon... pour le fun...
... on peut par exemple s'amuser à créer des types "Male" et "Female" qui encapsulent un animal d'une espèce donnée en précisant son sexe...
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 public class Test { public static void main(String[] args) { try { Couple<Bovin> couple = new Couple<Bovin>(Bovin.createMale("Horace"), Bovin.createFemale("Clarabelle")); System.out.println("Le taureau " + couple.getMale().getAnimal().getName() + " est marié à la vache " + couple.getFemale().getAnimal().getName() + " (parce que contrairement à Walt Disney je ne peux pas marier les vaches et les chevaux...)."); } catch (Throwable e) { e.printStackTrace(); } } } class Couple<E extends Animal> { private Male<E> male; private Female<E> female; public Couple(Male<E> male, Female<E> female) { this.male = male; this.female = female; } public Male<E> getMale() { return male; } public Female<E> getFemale() { return female; } } abstract class Animal {} class Bovin extends Animal { private String name; private Bovin(String name) { this.name = name; } public static Male<Bovin> createMale(String name) { return new Male<Bovin>(new Bovin(name)); } public static Female<Bovin> createFemale(String name) { return new Female<Bovin>(new Bovin(name)); } public String getName() { return name; } } class Male<E extends Animal> { private final E animal; public Male(E animal) { this.animal = animal; } public E getAnimal() { return animal; } } class Female<E extends Animal> { private final E animal; public Female(E animal) { this.animal = animal; } public E getAnimal() { return animal; } }

13/10/2009, 20h53
scary

D'accord je commence à comprendre un peu mieux :) maintenant et si je voulais faire des sous-classe de Bovin genre créer des classes de type Taureau ou Vache et ne plus utiliser Bovin mais seulement Vache et Taureau. Plus précisément ne plus utiliser les espèces mais le nom des animaux plutot.

Est ce que cela est possible ?
14/10/2009, 08h25
professeur shadoko

il faut au minimum quelque chose en commun comme une interface.
14/10/2009, 12h04
scary

D'accord et le mieux serait que je mette quel classe en interface ? Male et Femelle ?
14/10/2009, 12h24
professeur shadoko

non Bovin

Bon voila après un très long moment de réflexion et avec votre aide j'ai enfin pu faire comme je le souhaitais, je vous met le code des fichier .java au besoin si vous avez des commentaires à faire:D

Code:

1
2
3
public interface Femelle {
 
}

Code:

1
2
3
public interface Male {
 
}

Code:

1
2
3
public interface Membre<E> {
 
}

Code:

1
2
3
public class Bovin {
 
}

Code:

1
2
3
4
5
public class Taureau implements Membre<Bovin>, Male {
	public String toString () {
		return "Taureau";
	}
}

Code:

1
2
3
4
5
public class Vache implements Membre<Bovin>, Femelle {
	public String toString () {
		return "Vache";
	}
}

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
public class Couple<A, B> {
	private A membre1;
	private B membre2;
 
		public Couple () {}
 
		public Couple (A membre1, B membre2) {
			this.membre1 = membre1;
			this.membre2 = membre2;
		}
 
		public A getMembre1 () {
			return this.membre1;
		}
 
		public B getMembre2 () {
			return this.membre2;
		}
 
		public void setMembre1 (A membre1) {
			this.membre1 = membre1;
		}
 
		public void setMembre2 (B membre2) {
			this.membre2 = membre2;
		}
 
		public String toString () {
			return getMembre1 () + "-" + getMembre2 ();
		}
}

Code:

1
2
3
public class CoupleFertile<E, A extends Membre<E> & Male, B extends Membre<E> & Femelle> extends Couple<A, B> {
 
}

Voila avec ce code je peux maintenant manipulé les espèces ET les membres d'espèces:) Merci beaucoup à vous tous de votre aide:ccool:

16/10/2009, 11h17
dingoth

Je dirais que cette structure est bof... Selon ce schéma, un animal peut être à la fois mâle et femelle.

N'est-il pas préférable d'avoir une enum Male/Femelle accessible via animal, et de faire un test lors de la création d'un couple fertile et d'envoyer une InvalidArgumentException lorsqu'on a un mâle et une femelle ?
22/10/2009, 19h49
scary

Non lors de la création d'un couple il y a bien différenciation d'un mal et d'une femelle ;)
23/10/2009, 09h27
dingoth
Bah, regarde ce code qui va super bien compiler et s'intégrer dans le tien sans aucun problème :
Code:

1 2 3 4 5 6 7 public class Taurache extends Bovin implements Membre<Bovin>, Male, Femelle { } public class CoupleTaurache extends CoupleFertile<Bovin,Taurache,Taurache> { }
Si ça ne te dérange pas, ok. Sinon, il faut passer par une validation au Runtime, comme je l'ai dit auparavant !

Note, malgré ce cas particulier, j'aurais tout de même fait ceci :
Code:

1 2 3 class Bovin implements Membre<Bovin> { }
De cette manière, étendre Bovin suffit à en être membre.