Discussion :

[zouhour90]

Bonjour chers développeurs,

J'ai un problème au niveau du remplissage d'une liste de type "individual" qui est une classe crée par mois.
Il rempli toujours la liste par la dernière instance crée.
J'ai essayé d'afficher les deux instances avant et puis de les réafficher à partir de la liste. quand je les affiche indépendamment ça marche il me donne les deux instances crées par contre on les affichant à partir de la liste il m'affiche deux fois la dernière instance ajouter (indi1)

voilà le code:

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
individual indi=new individual();
		indi.setGene(U);
		indi.afficheIndiv(indi);
 
 
		individual indi1=new individual();
		indi1.setGene(U);
		indi1.afficheIndiv(indi1);
 
 
		ArrayList<individual>  individuals= new ArrayList<individual>();
 
        individuals.add(indi);
        individuals.add(indi1);
 
    for(int i=0;i<individuals.size();i++)
	    {
	    	individuals.get(i).afficheIndiv(individuals.get(i));
	    }

J'attends avec impatience vos commentaires. c'est très urgent.
Merci.

[tchize_]

Ton code ajoute bien deux instances séparée. Si elles affichent toutes les même données, alors le problème se trouve dans ta classe Individual. D'ailleurs vu qu'ils ont tous les deux juste une propriété gene qui est la même (U) pour les deux, je ne vous pas ce qui te permettrais de les différencier.

Aussi, ce code est plus que suspect et laisse à penser que ta classe Individual a de gros problèmes:

Code :

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

1
2
 
indi1.afficheIndiv(indi1);

en effet, une méthode d'un objet ne devrais pas avoir à recevoir en paramètre l'objet lui même.

[zouhour90]

Ton code ajoute bien deux instances séparée. Si elles affichent toutes les même données, alors le problème se trouve dans ta classe Individual. D'ailleurs vu qu'ils ont tous les deux juste une propriété gene qui est la même (U) pour les deux, je ne vous pas ce qui te permettrais de les différencier.

Aussi, ce code est plus que suspect et laisse à penser que ta classe Individual a de gros problèmes:

Code :

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

1
2
 
indi1.afficheIndiv(indi1);

en effet, une méthode d'un objet ne devrais pas avoir à recevoir en paramètre l'objet lui même.

Bonjour,

pour la méthode afficheIndiv j'ai enlevé le paramètre.
Mon problème c que ma classe "individual" contient 6 attributs de type tableau et chaque attribut se construit sous des conditions. (c a d j'ai beaucoup de méthodes qui s'appellent pour donner à la fin un attribut)

Je sais pas pourquoi si je crée dans la classe "main" beaucoup d'instance et puis je veux les afficher je fais

Code :

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

1
2
3
4
 
indi1.afficheIndiv();
indiv2.afficheIndiv();
indiv3.afficheIndiv();

ça m'affiche toujours les mêmes valeurs du dernier "individual" créé. C.à.d que les attributs gardent toujours les dernières valeurs du dernière instance crée.

[joel.drigo]

Salut,

Il se pourrait qu'on puisse t'aider si on pouvait voir le code de la classe individual... sans ça... à part des conjectures...ou des questions genre "les attributs de type tableau dont tu parles, ils seraient pas static des fois ?".

[zouhour90]

Salut,

Il se pourrait qu'on puisse t'aider si on pouvait voir le code de la classe individual... sans ça... à part des conjectures...ou des questions genre "les attributs de type tableau dont tu parles, ils seraient pas static des fois ?".

voilà le code oui les attributs sont statics:

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
package plateforme;
 
import java.util.ArrayList;
import java.util.Random;
 
public class individual {
 
     static int[][] geneZone;
	 static int[][] geneRemanufacturing;
	 static int[][] geneDeche;
	 static int[][] geneQR;
	 static int[][] geneQS;
	 static int[] geneVehicule;
 
	// generer un tableau de zone tout en respectant que la somme du tableau soit 1
 
	public int[] geneZ(int[] Plateforme) {
 
		int[] tab = new int[5];
 
		int somme = 0;
 
		while (somme != 1) {
			int som = 0;
			for (int i = 0; i < 5; i++) {
				if (Plateforme[i] == 1) {
					Random ran = new Random();
					int s = ran.nextInt(2);
					tab[i] = s;
				} else {
					tab[i] = 0;
				}
				som = som + tab[i];
			}
			somme = som;
		}
 
		return tab;
	}
 
	// generate 4 tableau de 4 zone
 
	public int[][] CreateZone(int[] Plateforme) {
		int[][] zone = new int[4][5];
		int[] tabZ = new int[5];
		for (int i = 0; i < 4; i++) {
			tabZ = geneZ(Plateforme);
			for (int j = 0; j < 5; j++) {
			zone[i][j] = tabZ[j];
			}
		}
		return zone;
	}
 
//	avoir les 4 zones tout en respectant que au moins 1 zone affectée 
	//si la plateforme elle est ouverte 
	public int[][] getZone(int[] Plateforme) {
 
		int[][] Zone = CreateZone(Plateforme);
 
		int[] somme = new int[5];
 
		for (int k = 0; k < 5; k++) {
			somme[k] = 0;
			for (int y = 0; y < 4; y++) {
				somme[k] += Zone[y][k];
			}
		}
		for (int i = 0; i < Plateforme.length; i++) {
			if (Plateforme[i] == 1) {
 
				while (somme[0] < 1 && somme[1] < 1 && somme[2] < 1 && somme[3] < 1 && somme[4] < 1) {
					int[] som = new int[5];
 
					Zone = CreateZone(Plateforme);
 
					for (int s = 0; s < 5; s++) {
 
						for (int j = 0; j < Zone.length; j++) {
							som[s] = Zone[j][i];
						}
					}
 
					for (int a = 0; a < 5; a++) {
						somme[a] = som[a];
					}
				}
			}
		}
		return Zone;
	}
 
	// generer un tableau de remanufacturing
	public int geneR(int[] tabr, int[] Plateforme) {
		int somme = 0;
		for (int i = 0; i < 5; i++) {
			if (Plateforme[i] == 1) {
				Random ran = new Random();
				int s = ran.nextInt(2);
				tabr[i] = s;
			} else {
				tabr[i] = 0;
			}
			somme = somme + tabr[i];
		}
		return somme;
	}
 
	// test le tableau de remanufacturing
	public int[] testR(int[] Plateforme) {
		int[] tabr = new int[5];
		int somme = geneR(tabr, Plateforme);
		while (somme == 0) {
			somme = geneR(tabr, Plateforme);
		}
		return tabr;
	}
 
	// generate 4 tableau de 4 remanufacturing
	public int[][] getRemanufacturing(int[] Plateforme) {
		int[] []Rema = new int[4][5];
		for (int i = 0; i < 4; i++) {
			int[] tabR = testR(Plateforme);
			for (int j = 0; j < 5; j++) {
				Rema[i][j] = tabR[j];
			}
		}
		return Rema;
	}
 
	// generer un tableau d'affectation de decheterie
	public int geneDeche(int[] tabD, int[] Plateforme) {
		int somme = 0;
		for (int i = 0; i < 5; i++) {
			if (Plateforme[i] == 1) {
				Random ran = new Random();
				int s = ran.nextInt(2);
				tabD[i] = s;
			} else {
				tabD[i] = 0;
			}
			somme = somme + tabD[i];
		}
		return somme;
	}
 
	// test les tableau d'affectation de decheterie
	public int[] testDeche(int[] Plateforme) {
		int[] tabD = new int[5];
		int somme = geneDeche(tabD, Plateforme);
		while (somme == 0) {
			somme = geneDeche(tabD, Plateforme);
		}
		return tabD;
	}
 
	// generer 2 tableau de decheterie
	public int[][] getDeche(int[] Plateforme) {
		int[][] deche = new int[2][5];
		for (int i = 0; i < 2; i++) {
			int[] tabD = testDeche(Plateforme);
			for (int j = 0; j < 5; j++) {
				deche[i][j] = tabD[j];
			}
		}
		return deche;
	}
 
	// generer une quantité retournée
	public int randQR(int AffeR) {
		int QR = 0;
		if (AffeR == 0) {
			QR = 0;
		} else {
 
			int x = 5000;
			QR = x;
		}
		return QR;
	}
 
	// // generer 4 tabelau de quantité retourné
 
	public int[][] generateQR() {
		int[][] TabQR = new int[4][5];
		int [][] Rema=getGeneRemanufacturing();
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 5; j++) {
				int QR = randQR(Rema[i][j]);
				TabQR[i][j] = QR;
			}
		}
		return TabQR;
	}
 
	// generer une quantité de decheterie
 
	public int randQS(int Affed) {
		int QS = 0;
		if (Affed == 0) {
			QS = 0;
		} else {
			Random ran = new Random();
			int x = 10000;
			QS = x;
		}
		return QS;
	}
 
	// // generer 4 tabelau de quantité de decheterie
	public int[][] generateQS() {
		int[][] TabQS = new int[2][5];
		int[][] deche=getGeneDeche();
		for (int i = 0; i < 2; i++) {
			for (int j = 0; j < 5; j++) {
 
				int QS = randQS(deche[i][j]);
				TabQS[i][j] = QS;
			}
		}
		return TabQS;
	}
 
	// generer un tableau de vehicules
	public int[] randVeh(int[] Plateforme) {
 
		int[] TabVeh = new int[5];
		for (int i = 0; i < 5; i++) {
			if (Plateforme[i] == 0) {
				TabVeh[i] = 0;
			} else {
				Random ran = new Random();
				int x = ran.nextInt(5) + 1;
				TabVeh[i] = x;
			}
		}
		return TabVeh;
	}
 
	public int[][] getGeneZone() {
		return geneZone;
	}
 
	public void setGeneZone(int[][] geneZone1) {
		geneZone = geneZone1;
	}
	public void setGeneZone(int[] plateforme)
	{
		geneZone=getZone(plateforme);
	}
 
	public int[][] getGeneRemanufacturing() {
		return geneRemanufacturing;
	}
 
	public void setGeneRemanufacturing(int[][] geneRemanufacturing1) {
		geneRemanufacturing = geneRemanufacturing1;
	}
 
	public void setGeneRemanufacturing(int[] Plateforme) {
		geneRemanufacturing = getRemanufacturing(Plateforme);
	}
 
	public int[][] getGeneDeche() {
		return geneDeche;
	}
 
	public void setGeneDeche(int[][] geneDeche1) {
		geneDeche = geneDeche1;
	}
 
	public void setGeneDeche(int[] Plateforme) {
		geneDeche = getDeche(Plateforme);
	}
 
 
	public int[][] getGeneQR() {
		return geneQR;
	}
 
	public void setGeneQR(int[][] geneQR1) {
		geneQR = geneQR1;
	}
	public void setGeneQR() {
		geneQR = generateQR();
	}
 
	public int[][] getGeneQS() {
		return geneQS;
	}
 
	public void setGeneQS(int[][] geneQS1) {
		geneQS = geneQS1;
	}
	public void setGeneQS() {
		geneQS = generateQS();
	}
 
	public int[] getGeneVehicule() {
		return geneVehicule;
	}
 
	public void setGeneVehicule(int[] geneVehicule1) {
		geneVehicule = geneVehicule1;
	}
 
	public void setVehicule(int[] Plateforme) {
 
		geneVehicule = randVeh(Plateforme);
	}
public individual setIndiv(int[] Plateforme) {
		individual indi = new individual();
 
		indi.setGeneZone(Plateforme);
		indi.setGeneRemanufacturing(Plateforme);
		indi.setGeneDeche(Plateforme);
		indi.setGeneQR();
		indi.setGeneQS();
		indi.setVehicule(Plateforme);
 
		return indi;
	}
 
	public void afficheIndiv() {
 
		System.out.println("Gene Zone");
 
		for (int i = 0; i < geneZone.length; i++) {
			System.out.println("");
			for (int j = 0; j < geneZone[i].length; j++) {
				System.out.print(geneZone[i][j] + "//");
			}
 
		}
 
		System.out.println("");
		System.out.println("gene Remanufacturing");
 
		for (int i = 0; i < geneRemanufacturing.length; i++) {
			System.out.println("");
			for (int j = 0; j < geneRemanufacturing[i].length; j++) {
				System.out.print(geneRemanufacturing[i][j] + "//");
			}
 
		}
		System.out.println("");
		System.out.println("gene Dechet");
 
		for (int i = 0; i < geneDeche.length; i++) {
			System.out.println("");
			for (int j = 0; j < geneDeche[i].length; j++) {
				System.out.print(geneDeche[i][j] + "//");
			}
 
		}
		System.out.println("");
		System.out.println("Gene QR");
		for (int i = 0; i < geneQR.length; i++) {
			System.out.println("");
			for (int j = 0; j < geneQR[i].length; j++) {
				System.out.print(geneQR[i][j] + "//");
			}
 
		}
		System.out.println("");
		System.out.println("Gene QS");
 
		for (int i = 0; i < geneQS.length; i++) {
			System.out.println("");
			for (int j = 0; j < geneQS[i].length; j++) {
				System.out.print(geneQS[i][j] + "//");
			}
 
		}
		System.out.println("");
		System.out.println("Gene Vehicule");
		for (int k = 0; k < geneVehicule.length; k++) {
			System.out.print(geneVehicule[k] + "//");
		}
 
	}
 
}

[joel.drigo]

Bah, voilà, la réponse est là. static fait que l'attribut n'est pas un attribut d'instance mais de classe. C'est un peu comme si c'était la même variable partagée entre toutes les instances (pas tout à fait, parce que ça existe aussi même quand il y a aucune instance).

Donc si tu mets une valeur dans ton tableau, même en passant par le nom de la variable qui pointe sur l'instance, ça change la valeur pour toutes les instances en même temps.

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
public class Exemple {
   public static int i=0;
 
   public static void main(String[] args) {
 
 
         Exemple e1 = new Exemple();
         e1.i = 42;
 
         Exemple e2 = new Exemple();
         e2.i = 18;
 
         System.out.println( e1.i );
 
   }
 
 
}

affiche 18 !

D'ailleurs, on évite d’accéder à une variable static par une variable , mais par le nom de la classe (Exemple.i dans mon exemple), et ton IDE devrait t'alerter à ce sujet.

En général, excepté pour des static final (des constantes de paramétrage) et des méthodes utilitaires et la méthode main, il ne devrait pas y avoir de static dans ton programme. S'il y en a, ça devrait t'alerter sur le fait qu'il y a un souci. Par la suite, tu pourras t'en servir quand tu connaîtras mieux son fonctionnement, mais pour l'instant n'utilise pas static pour des variables. En particulier, si tu obtiens une erreur de compilation qui te tente de remettre static, tentation à laquelle il ne faut pas céder, ça te permet de voir tout de suite qu'il y'a un gros problème dans ton architecture.

[zouhour90]

En fait juste j'ai oublié de donner en paramètre le tableau dans la construction des instances dans le main.

Merci beaucoup ça marché