Discussion :

[scary]

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

[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 :

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

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

[professeur shadoko]

petits commentaires supplémentaires...

ça serait mieux comme ça

Code :

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

1
2
3
4
5
 
class AnimalSage<A extends AnimalSage> {
    public void sePacseAvec(A lAutre) {
  }
}

et bien entendu il faut créer :

Code :

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

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?)

[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 :

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

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 :

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

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.

[adiGuba]

Salut,


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

Code :

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

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

a++

[scary]

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 :

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

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

[Astartee]

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 :

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

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

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 :

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

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;
   }
 
}

[LittleBean]

Je crois que l'idée est d'avoir la signature suivante pour la classe

Code :

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

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

avec des appels de la forme :

Code :

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

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

[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++

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

[professeur shadoko]

Code :

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

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

[Astartee]

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

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

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 :

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
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;
	}
}

[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 ?

[professeur shadoko]

il faut au minimum quelque chose en commun comme une interface.

[scary]

D'accord et le mieux serait que je mette quel classe en interface ? Male et Femelle ?

[professeur shadoko]

non Bovin

[scary]

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

Code :

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

1
2
3
public interface Femelle {
 
}

Code :

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

1
2
3
public interface Male {
 
}

Code :

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

1
2
3
public interface Membre<E> {
 
}

Code :

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

1
2
3
public class Bovin {
 
}

Code :

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

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

Code :

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

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

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

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

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

[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 ?

[scary]

Non lors de la création d'un couple il y a bien différenciation d'un mal et d'une femelle

[dingoth]

Bah, regarde ce code qui va super bien compiler et s'intégrer dans le tien sans aucun problème :

Code :

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

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 :

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

1
2
3
class Bovin implements Membre<Bovin> {
 
}

De cette manière, étendre Bovin suffit à en être membre.