Discussion :

[klide]

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

[jibbi]

Salut

Je commence a etre serieusement confus

J'ai lu ton code et moi aussi


La class Main est assez inutile.
Ajoute la méthode static void main(String [] arg) à la 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
 
public class Application {
	Action ac = new Action();
	// ----- Operations -----
	public void run(){
		ac.initializeClassA();
		ac.displayAll();
	} // method: run
             public static void main(String [] arg){
                    new Application().run();
             }
 
} // class Application

J'ai l'impression qu'il y a une erreur de copier-coller ici:

Code :

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

1
2
3
4
 
clb1.addRoom(clc1); // OK
clb1.addRoom(clc2); // clb2 au lieu de clb1 ?
clb2.addRoom(clc3); // clb3 au lieu de clb2 ?

En placant tes champs a la fin des classes, on perd tu temps à lire ton code surtout lorsque quelqu'un d'autre cherche des erreur...

Code :

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

1
2
3
4
5
 
// ----- Attributes -----
	private String theClassBID = "";
	private Collection <ClassC> ClassCs;
} // class ClassB

Déplace-les juste après la déclaration de ta classe.

Les classe ClassA, ClassB, ClassC sont quasi identique.
La seule différence entre A et B, C c'est:
-A possède une Collection de B
-B possède une Colletion de C.
-C possède aucune Collection.

Utilise l'héritage pour éviter de écrire le même code 3 fois
Exemple

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
 
public Class Simple {
    public String ID = "";
    public ArrayList<Simple>  list = new ArrayList();
 
   /* ajouter toute les traitement identique ici
    *
    */
 
   // j'ai ajouté ca, expliquer plus loin, pour répondre à ta question :o)
    public static ArrayList<Simple> allInstance = new ArrayList();
   public Simple(){}
   public Simple(String ID){
       this.ID = ID;
      allInstance.add(this);
   }
   public void printAll(){
             // imprimer toutes les ID des Objet de la list
             // si vide imprimer "vide"
             Iterator all = allInstance.iterator();
             while(all.hasNext()){
                       Simple s = (Simple) all.next();
                       s.printList() 
             }
   }
 
   public void printList(){
              System.out.println(ID);
              if (list.isEmpty()) {
                    System.out.println("\tvide");
               }
              else {
                  Iteratort i = list.iterator();
                  while(i.hasNext()){
                       System.out.println("\t" + i.next());
                  }
              }
   }
   public String ToString(){
        return ID;
   }   
}
 
 
public Class A extends Simple {
 
}
 
public Class B extends Simple {
}
 
public Class C extends Simple {
 
}

La classe Simple possède une Collection static de tous les instance de Simple qui seront créé avec le constructeur Simple(String ID).
Donc pour tout imprimer

Code :

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

1
2
3
4
5
6
 
A.printAll();
// équivalent à
B.printAll();
// équivalent à
c.printAll();

La structure du output devrait ressempler à cela:
simple
element 1..
element n
simple
vide


Notez que je n'ai rien complié donc, il se peut qu'il y ait quelques erreur...

[klide]

Salut,

La solution proposee est interessant. Mais quel est l'avantage d'avoir une class Simple (peut-etre en abstract?) et des classes concretes?

Le programme de base, que j'ai simplifie de facon un peu extreme, fait appelle a des classes liees par des relations one-to-many:

• ClassA(1)-(*)ClassB
• ClassB(1)-(*)ClassC

Je suppose qu'il me manque des "getter" pour la Collection de ClassCs dans la class ClassB, pour pouvoir afficher celle-ci lors d'un appel de la methode displayAll().

Seulement, les classes ne possedent pas forcement les memes identifiants. Lorsque je parlais de parametres "String ID", c'est dans l'idee de multiplier les parametres au fur et a mesure que les classes grandissent, qu'ils soient des String, des integer ou des boleans. Je comprends un peu mieux la logique sous-jacente.

J'ai utiliser les Iterators avant et je cherchais a comprendes et remplacer mes "while loop" par des "extended for loop", permit par Java 1.5.

merci encore pour l'aide.

Tam

[klide]

RTFM: je crois que c'etais la solution .... J'ai passe plusieurs heures de lectures sur une publication O'Reilly (Java 5.0 Tiger: A Developer's Notebook ). Il y avait tout sur l'utilisation de la "foreach loop", ou "enhanced for loop".

Merci pour l'aide et les idees de recherche.


Tam

[jibbi]

Mais quel est l'avantage d'avoir une class Simple

L'avantage est que chaque sous class A, B et C peuvent être traité comme un calsse Simple. Donc ca fait beaucoup moin de méthode à écrire. Par exemple:

Dans ton code les méthodes:

Code :

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

1
2
3
 
public void addClassB(ClassB aClassB)
public void addClassC(ClassC aClassC)

Peuvent être remplacé par une seul méthode de super Classe Simple

Code :

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

1
2
 
public void add(Simple simple)

ensuite on peut faire:

Code :

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

1
2
3
4
5
6
 
add(ClassA);
[...]
add(ClassB);
[...]
add(ClassC);

Je suppose qu'il me manque des "getter" pour la Collection de ClassCs dans la class ClassB, pour pouvoir afficher celle-ci lors d'un appel de la methode displayAll().

Dans l'exemple que j'ai fait, un seul appel à printAll() de la class Simple est suffisant pour tout imprimer les ID de chaque object A, B, C qui ont été créé. Remarque que la liste qui tiens en mémoire les instances est static.

[klide]

Je vois mieux ou tu voulais en venir. Je suis repartie sur des Iterators et des while loop, connaissant ca un peu mieux; Il me fallait pouvoir modifier mes Collections dans la boucle, par ajout ou suppression d'un ou plusieur elements.

il me reste plus qu'a mettre des filtres en place afin de verifier que les elements apportes par l'utilisateur soit bien crees et references.

Tam