[ Composition ] Une classe composée d'une autre classe

Bonjour,

je me suis lancé dans un petit projet pour apprendre Java.

J'essaie de coder en réel un objet A.

Cet objet est lui-même composé de plusieurs objets B ( de 0 à 5 max).

Ce que je n'arrive pas à faire c'est de coder cette relation, que je crois qu'on appelle composition (car si l'object A est tué les objets B aussi !)

J'ai bien compris comment faire uen relation quand il n'y a qu'un objet B mais pas quand il y 'e a plusieurs !

Avez vous une idée svp ?

merci

AprentiJava.

En fait il faut utiliser un ArrayList dans l'objet A (celui qui est composé de 0 ou de plusieurs objects B).

Si tu nous fournissais un bout de code .... :D

Citation:

Envoyé par exe2bin

Si tu nous fournissais un bout de code .... :D

C'est pas faux ! :p

En fait je pensais utiliser une composition entre mes deux classes mais je ne voyais pas comment la coder.

Finalement j'ai utilisé un "ArrayList" et celà fonctionne !

maintenant j'ai une autre problèmetique avec une autre classe. Je dois associé les slots d'un tuile avec des pions.

Les pions ne peuvent s'associer qu'avec des slots qui ont une même taille, et qui ont au moins 1 code couleur semblable.

Ma classe Tuile qui est composé de 0 à 4 slots :

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
 
 
import java.util.ArrayList;
public class Tuile {
 
	String NomTuile;
	String CommentaireTuile;
	String NomArmee;
	int PointArmee;
	int NbreOrdres;
 
public ArrayList<Slot> slots;
 
 
 
	// Constructeur par défaut :
	public Tuile(){
		NomTuile="Défaut";
		CommentaireTuile="Défaut";
		NomArmee="Défaut";
		PointArmee=0;
		NbreOrdres=0;
		slots = new ArrayList<Slot>();		
 
	}
 
	public Tuile(String pNomTuile, String pCommentaireTuile,String pNomArmee,int pPointArmee,int pNbreOrdres){
		NomTuile=pNomTuile;
		CommentaireTuile=pCommentaireTuile;
		NomArmee=pNomArmee;
		PointArmee=pPointArmee;
		NbreOrdres=pNbreOrdres;
		//slotTuile = new Slot[pNbreSlots];
		slots = new ArrayList<Slot>();	
 
	}
 
 
 
	//methode 
 
	public void AfficherCaracTuile(){
		System.out.println("###############################################");
		System.out.println("#         Caractéristiques d'un tuile         #");
		System.out.println("###############################################");
		System.out.println("Nom de la Tuile : " + this.NomTuile);
		System.out.println("Sous-nom de la Tuile : " + this.CommentaireTuile);
		System.out.println("Nomde l'Armee : " + this.NomArmee);
		System.out.println("Point de l'Armee : " + this.PointArmee);
		System.out.println("Nombre d'ordres : " + this.NbreOrdres);
 
		// les slots utilisés 
		if(this.slots.size()>0){
			for(int i=0;i<this.slots.size();i++){
				System.out.println(this.slots.get(i).SlotTaille +" Slot de " + this.slots.get(i).SlotPosition + " Code-couleurs " + this.slots.get(i).SlotCodeCouleur1 + " et  " + this.slots.get(i).SlotCodeCouleur2);
				if(this.slots.get(i).SlotPlein==false )
				{
					System.out.println("Le slot n'est pas utilisé, il est donc encore disponible");
				}
				else
				{
					System.out.println("Le slot est utilisé, il n'est plus disponible");
				}
			}
		}
		else
		{
			System.out.println("Aucun slot pour cette tuile : " + this.NomTuile + " ( " + this.CommentaireTuile + " )");
		}
 
 
	}
 
 
	public void ModifierSlotplein(int i){
		System.out.println(this.slots.get(i).SlotPlein);
		if(this.slots.get(i).SlotPlein == false)
		{
			this.slots.get(i).SlotPlein = true;
		}
		else
		{
			this.slots.get(i).SlotPlein = false;
		}
 
 
	}

Ma classe Slot :

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
 
public class Slot {
 
	//Atributs
	String SlotTaille;
	String SlotCodeCouleur1;
	String SlotCodeCouleur2;
	String SlotPosition;
	Boolean SlotPlein;
 
 
 
	//Constructeur
	public Slot() {
		SlotTaille="Defaut";
		SlotCodeCouleur1="Defaut";
		SlotCodeCouleur2="Defaut";
		SlotPosition="Defaut";
		SlotPlein=false;
	}
 
	public Slot(String pSlotTaille, String pSlotCodeCouleur1,String pSlotCodeCouleur2, String pSlotPosition, Boolean pSlotPlein) {
		SlotTaille=pSlotTaille;
		SlotCodeCouleur1=pSlotCodeCouleur1;
		SlotCodeCouleur2=pSlotCodeCouleur2;
		SlotPosition=pSlotPosition;
		SlotPlein=pSlotPlein;
 
	} 
 
 
 
	//Mutateurs
 
	public void setSlotTaille(String pSlotTaille) {
		SlotTaille=pSlotTaille;
	}
 
	public void setSlotCodeCouleur1(String pSlotCodeCouleur1) {
		SlotCodeCouleur1=pSlotCodeCouleur1;
	}
 
	public void setSlotCodeCouleur2(String pSlotCodeCouleur2) {
		SlotCodeCouleur2=pSlotCodeCouleur2;
	}	
 
	public void setSlotPosition(String pSlotPosition) {
		SlotPosition=pSlotPosition;
	}	
 
	public void setSlotPlein(Boolean pSlotPlein) {
		SlotPlein=pSlotPlein;
	}	
 
 
 
	//Accesseurs
	public String getSlotTaille(){
		return SlotTaille;
	}
 
	public String getSlotCodeCouleur1(){
		return SlotCodeCouleur1;
	}
 
	public String getSlotCodeCouleur2(){
		return SlotCodeCouleur2;
	}
 
	public String getSlotPosition(){
		return SlotPosition;
	}
 
	public Boolean getSlotPlein(){
		return SlotPlein;
	}
 
 
 
 
	//Methode 
 
 
	public void AfficherSlot(){
		System.out.println("Le " + SlotTaille +" Slot en position " + SlotPosition + " a son 1er code-couleurs  : "  + SlotCodeCouleur1 + " et son 2ieme Code couleur  : " + SlotCodeCouleur1 + ".");
 
	}
 
}

Ma classe Main :

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
 
public class Main {
 
	/**
         * @param args
         */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
 
		Tuile tuile0001 = new Tuile("Rifle Platoon","4TH INF. 3TH INF. REG","US",70,2);
		//Constructueur des  Slot(String pSlotTaille, String pSlotCodeCouleur1,String pSlotCodeCouleur2, String pSlotPosition, Boolean pSlotPlein)
		tuile0001.slots.add(new Slot("Grand","JauneBlanc","JauneBlanc","Gauche",false));
		tuile0001.slots.add(new Slot("Petit","GrisNoirGris","GrisNoirGris","MilieuGauche",false));
		tuile0001.slots.add(new Slot("Petit","GrisNoirGris","GrisNoirGris","MilieuDroit",false));
		tuile0001.slots.add(new Slot("Grand","JauneBlanc","JauneBlanc","Droit",false));
 
		tuile0001.AfficherCaracTuile();
 
		//tuile0001.ModifierSlotplein(1);
 
		//tuile0001.AfficherCaracTuile();
 
		//Constructeur des Pion(String pPionCodeCouleur1,String pPionCodeCouleur2, String pPionTaille,String pPionNom,String pPionArmee,int pPionPoint
		Pion pion0001 = new Pion("JauneBlanc","JauneBlanc","Grand","RIFFLE SQUAD","US",50,false);
		Pion pion0002 = new Pion("JauneBlanc","JauneBlanc","Grand",".30 CAL SQUAD","US",50,false);
		Pion pion0003 = new Pion("JauneBlanc","JauneBlanc","Grand","BAZOOKA SQUAD","US",55,false);
		Pion pion0004 = new Pion("GrisNoirGris","GrisNoirGris","Grand","SHERMAN M4","US",60,false);
		Pion pion0005 = new Pion("GrisNoirGris","GrisNoirGris","Grand","M5 STUART","US",50,false);
		Pion pion0006 = new Pion("GrisNoirGris","GrisNoirGris","Grand","M8 SCOTT","US",50,false);
 
		pion0001.AfficherCaracPion();
 
 
	}
 
}

Ensuite ma classe Pion. Cette classe va etre associée aux Slots. Un Slot ne pourra recevoir qu'un seul pion, de meme taille et dont 1 des codes couleurs est similaire à celui du pion ! Et là aussi je bloque !

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
 
public class Pion {
 
	String PionCodeCouleur1;	
	String PionCodeCouleur2;	
	String PionTaille;
	String PionNom;
	String PionArmee;
	int PionPoint;
	Boolean PionUtilise;
 
 
	Pion(){
		PionCodeCouleur1="Defaut";	
		PionCodeCouleur2="Defaut";	
		PionTaille="Defaut";
		PionNom="Defaut";
		PionArmee="Defaut";
		PionPoint=0;
		PionUtilise=false;
	}
 
	public Pion(String pPionCodeCouleur1,String pPionCodeCouleur2, String pPionTaille,String pPionNom,String pPionArmee,int pPionPoint, Boolean pPionUtilise){
		PionCodeCouleur1=pPionCodeCouleur1;	
		PionCodeCouleur2=pPionCodeCouleur2;	
		PionTaille=pPionTaille;
		PionNom=pPionNom;
		PionArmee=pPionArmee;
		PionPoint=pPionPoint;
		PionUtilise=pPionUtilise;
	}	
 
 
 
 
 
	//Methodes :
 
	public void AfficherCaracPion(){
		System.out.println();
		System.out.println("###############################################");
		System.out.println("#          Caractéristiques d'un pion         #");
		System.out.println("###############################################");
		System.out.println("Le pion : " + this.PionNom );
		System.out.println("L'armée du pion	: " + this.PionArmee );
		System.out.println("Le code-couleurs de gauche : " + this.PionCodeCouleur1 );
		System.out.println("Le code-couleurs de droite : " + this.PionCodeCouleur2 );
		System.out.println("La taille du pion : " + this.PionTaille );
		System.out.println("Le coût d'achat du pion : " + this.PionPoint );
		if(this.PionUtilise==false)
		{
			System.out.println("Le pion n'est pas utilisé, il est donc encore disponible");
		}
		else
		{
			System.out.println("Le pion est utilisé, il n'est plus disponible");
		}
 
 
	}	
 
 
}

3 pièce(s) jointe(s)

Juste pour vous donner une idée de ce qu'est une tuile, un slot et un pion :)

Voici une "tuile" avec 4 slots
Pièce jointe 293888

Un pion de grande taille et avec des code couleur jaune Blanc
Pièce jointe 293891

Un pion de grande taille et avec des code couleur NoirGrisNoir
Pièce jointe 293893

Papier + crayon avant le clavier, ça permet d'avoir une meilleure vue d'ensemble.

Une armée est composé de 1 à X tuiles.

1 tuile est composée physiquement de 0 à 5 slots (qui est finalement lui-meme un objet !).

on associe un et un seul pion par slot en meme temps. Par contre plusieurs pions sont candidats à remplir 1 slot. ( les pions doivent être de meme taille que le slot, et le pion doit avoir au moins 1 de ses codes couleurs semblables à un des codes couleurs du slot !).

Je n'arrive simplement pas à comprendre comment mettre "les liens" dans l'écriture des classes.