Bonjour,

J'aimerais bien avoir des explications pour passer des messages entre classes. Voila j'ai un projet ou je me retrouve avec 6 classes:
  1. Main,
  2. Application,
  3. Action,
  4. ClassA,
  5. ClassB,
  6. ClassC.


La class Main appelle Application, qui elle-meme appelle Action. Cette derniere possede la plus part des methodes pour creer des nouvelles instances de ClassA, ClassB, ClassC. Ce sont souvent des references a des methodes de creation d'instance d'objects (ie: ClassA va avoir une methode de creation d'instance de ClassB, et ClassB une methode de creation d'instance de ClassC).

De plus ClassA possede une Collection d'object relatif aux instance de ClassB et ClassB une Collection relatif a ClassC. Du coup une methode de creation d'instance de ClassB a l'interieur de ClassA fait appelle a une methode ajoutant cette instance a la Collection.

Je cherche a verifier dans un permier temps que les nouvelles instances soient bien crees. Mais sans grands resultat. Je commence a etre serieusement confus a propos de ces passages de message. ...

voici l'output:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
 
ClassBID: 1
ClassBID: 2
ClassBID: 3
je vous met un bout de code pour rendre plus explicite tout ca:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
 
public class Main {
 
	public static void main(String[] args) {
		Application app = new Application();
		app.run();
	} // method: main
 
} // class Main
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
 
public class Application {
	Action ac = new Action();
	// ----- Operations -----
	public void run(){
		ac.initializeClassA();
		ac.displayAll();
	} // method: run
} // class Application
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
 
public class Action {
	// Create a new classA
	ClassA classA = new ClassA();
	public void initializeClassA(){
		// Create some new classB
		ClassB clb1 = new ClassB("1");
		ClassB clb2 = new ClassB("2");
		ClassB clb3 = new ClassB("3");
		// Create some new classC
		ClassC clc1 = new ClassC("a");
		ClassC clc2 = new ClassC("b");
		ClassC clc3 = new ClassC("c");
		// add the classB to the classA
		classA.addClassB(clb1);
		classA.addClassB(clb2);
		classA.addClassB(clb3);
 		// assign the classC to some classB
		clb1.addRoom(clc1);
		clb1.addRoom(clc2);
		clb2.addRoom(clc3);
	} // method: initializeClassA
	public void displayAll(){
		String all = classA.displayClassA();
		ConsoleIO.out.println(all);
	} // method: displayAll
} // class Action
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
 
import java.util.*;
public class ClassA {
	// ----- Operations -----
	public ClassA(){
		classBs = new ArrayList <ClassB>();
	} // method: ClassA
	public void createClassB(String aClassBID){
		ClassB classB = new ClassB(aClassBID);
		this.addClassB(classB);
	} // method: createClassB
	public void addClassB(ClassB aClassB){
		classBs.add(aClassB);
	} // method: addClassB
	public void removeClassB(ClassB aClassB){
		classBs.remove(aClassB);
	} // method: removeClassB
	public String displayAllClassBs(){
		String allClassBs = "";
		for(ClassB classB:classBs){
			allClassBs += toString(classB.getClassBID());
		}
		return allClassBs;
	} // method: display
	public String displayClassA(){
		String allClassA = "";
		for(ClassB classB:classBs){
			allClassA += toString(classB.getClassBID());
			classB.displayAllClassCs();
		}
 
		return allClassA;
	}
	public String toString(String aClassBID){
		String stringClassB = "ClassB number: " + aClassBID + "\n";
		return stringClassB;
	}
	// ----- Attributes -----
	private Collection <ClassB> classBs;
} // class ClassA
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
 
import java.util.*;
public class ClassB {
 
	// ----- Operations -----
	public ClassB(String aClassBID) {
		// Initialize normal attributes
		theClassBID = aClassBID;
		ClassCs = new ArrayList <ClassC> ();
	} // method: ClassB
	public String getClassBID() {
		return theClassBID;
	} // method: getClassBID
	public void setClassBID(String aClassBID) {
		this.theClassBID = aClassBID;
	} // method: setClassBID
	public void createClassC(String aClassCID){
		ClassC ClassC = new ClassC(aClassCID);
		this.addClassC(ClassC);
	} // method: createClassC
	public void addClassC(ClassC aClassC){
		ClassCs.add(aClassC);
	} // method: addClassC
	public void removeClassC(ClassC aClassC){
		ClassCs.remove(aClassC);
	} // method: removeClassC
	public String displayAllClassCs(){
		String allClassCs = "";
		for(ClassC ClassC:ClassCs){
			allClassCs += toString(ClassC.getClassCID());
		}
		return allClassCs;
	} // method: display
	public String toString(String aClassCID){
		String stringClassC = "" + aClassCID;
		return stringClassC;
	} // method: toString
	// ----- Attributes -----
	private String theClassBID = "";
	private Collection <ClassC> ClassCs;
} // class ClassB
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
 
public class ClassC {
 
	// ----- Operations -----	
	public ClassC(String aClassCID){
		theClassCID = aClassCID;
	} // method: ClassC
	public String getClassCID() {
		return theClassCID;
	} // method: getClassCID
	public void setClassCID(String theClassCID) {
		this.theClassCID = theClassCID;
	} // method: setClassCID
	public String toString(){
		return "ClassC ID: " + theClassCID;
	} // method: toString
	// ----- Attributes -----
	private String theClassCID = "";
} // class ClassC