[debutant] message passing entre class
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:
- Main,
- Application,
- Action,
- ClassA,
- ClassB,
- 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:
1
2
3
4
|
ClassBID: 1
ClassBID: 2
ClassBID: 3 |
je vous met un bout de code pour rendre plus explicite tout ca:
Code:
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:
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:
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:
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:
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:
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 |
