Figer et stocker une valeur qui évolue, un temps

Version imprimable

Bonjour,

Après une petite recherche sur internet, je n'ai pas trouvé de réponse à mon problème...

Je viens donc vous solliciter !

Voilà je voudrais stocker dans des listes de string(timeString)/double(dCount) un temps de cette forme :

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
// Update of time...............................................................................
			String timeString = "";
			if ((int) (dCount / 3600) < 10) {
				timeString = timeString + "0" + (int) (dCount / 3600) + ":";
				//System.out.println(timeString + "0" + (int) (dCount / 3600));
			} else {
				timeString = timeString + (int) (dCount / 3600) + ":";
				//System.out.println(timeString + (int) (dCount / 3600)); naffiche rien
			}
			if ((int) ((dCount - (int) (dCount / 3600) * 3600) / 60) < 10) {
				timeString = timeString + "0" + (int) ((dCount - (int) (dCount / 3600) * 3600) / 60) + ":";
				//System.out.println(timeString + "0" + (int) ((dCount - (int) (dCount / 3600) * 3600) / 60)); //affiche min et sec val identique (pas les dizaines)
			} else {
				timeString = timeString + (int) ((dCount - (int) (dCount / 3600) * 3600) / 60) + ":";
				//System.out.println( timeString + (int) ((dCount - (int) (dCount / 3600) * 3600) / 60));de meme mais a partir des dizaine
			}
			if ((int) (dCount - 60 * (int) (dCount / 60)) < 10) {
				timeString = timeString + "0" + (int) (dCount - 60 * (int) (dCount / 60));
				//System.out.println(timeString + "0" + (int) (dCount - 60 * (int) (dCount / 60)));//affiche la valeur exacte au centieme pres meme dizaine
			} else {
				timeString = timeString + (int) (dCount - 60 * (int) (dCount / 60));
				//System.out.println(timeString + (int) (dCount - 60 * (int) (dCount / 60)));//de meme
			}
 
			mFrame.getJpCommandSim().getJlTime().setText(timeString);
 
 
			dCount = dCount + dSimulationCycleTime;

Je voudrais donc stocker la valeur de timeString et dCount dans une liste en figeant la valeur qu'ils avaient au moment où je les met dans le tableau.

Car si je fais un simple add sur la liste, la valeur continue de changer...

Merci par avance pour vos lumières :)

c'est pas très clair ta demande. Tu a besoin de savoir quel dcount a servis à générer une String donnée? Parce que dans ton code là, il n'y a aucun notion de liste, donc dur dur de savoir ce que tu veux faire.

Si t'as besoin de retrouver le dcount, utiliser une Map

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
private Map<String,Integer> dcountMap = new HashMap<>();
//.....
 
 
// Update of time...............................................................................
			String timeString = "";
			if ((int) (dCount / 3600) < 10) {
				timeString = timeString + "0" + (int) (dCount / 3600) + ":";
				//System.out.println(timeString + "0" + (int) (dCount / 3600));
			} else {
				timeString = timeString + (int) (dCount / 3600) + ":";
				//System.out.println(timeString + (int) (dCount / 3600)); naffiche rien
			}
			if ((int) ((dCount - (int) (dCount / 3600) * 3600) / 60) < 10) {
				timeString = timeString + "0" + (int) ((dCount - (int) (dCount / 3600) * 3600) / 60) + ":";
				//System.out.println(timeString + "0" + (int) ((dCount - (int) (dCount / 3600) * 3600) / 60)); //affiche min et sec val identique (pas les dizaines)
			} else {
				timeString = timeString + (int) ((dCount - (int) (dCount / 3600) * 3600) / 60) + ":";
				//System.out.println( timeString + (int) ((dCount - (int) (dCount / 3600) * 3600) / 60));de meme mais a partir des dizaine
			}
			if ((int) (dCount - 60 * (int) (dCount / 60)) < 10) {
				timeString = timeString + "0" + (int) (dCount - 60 * (int) (dCount / 60));
				//System.out.println(timeString + "0" + (int) (dCount - 60 * (int) (dCount / 60)));//affiche la valeur exacte au centieme pres meme dizaine
			} else {
				timeString = timeString + (int) (dCount - 60 * (int) (dCount / 60));
				//System.out.println(timeString + (int) (dCount - 60 * (int) (dCount / 60)));//de meme
			}
 
			mFrame.getJpCommandSim().getJlTime().setText(timeString);
			dcountMap.put(timeString,dCount);
 
			dCount = dCount + dSimulationCycleTime;

Non, je sais où est le dCount et comment il est construit.

En gros c'est comme un relevé en physique-chimie, à certains moments je dois relever le temps.

Cette valeur du temps, je voudrais la mettre dans une liste.

Ma liste en gros c'était:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 LinkedList<Double> lCount = new LinkedList; LinkedList<String> lTimeString = new LinkedList; ... //action qui rend nécessaire un relevé du temps lCount.add(dCount); lTimeString.add(timeString);

07/08/2015, 18h55
tchize_

Et qu'est-ce qui coince là dedans? Tu m'a l'air de l'ajouter dans la liste là.
07/08/2015, 19h03
Cafeinoman
Tu as essayé avec
Code:

1 2 3 listeString.add(new String(timestring)); listeDouble.add(new Double(dcount));
Si je comprend bien ton problème, ça devrait le regler...
07/08/2015, 19h12
tchize_
Citation:

Envoyé par Cafeinoman

Tu as essayé avec

PAN! Les constructeur String(String) est à ne jamais utiliser, sauf si tu veux gaspiller ta mémoire :mouarf: Et ce code est fonctionnellement identique à
Code:

1 2 listeString.add((timestring)); listeDouble.add(dcount);
07/08/2015, 19h27
Cafeinoman

@Tchize_ Je te rassure, je ne le fais pas dans mon code... Promis j'arrête d'être inattentif.

Peux tu fournir une impression des valeurs de la liste après quelques enregistrements?
07/08/2015, 21h57
cos12

Merci pour vos propositions, j'essaye ça dès que possible (même si c'est aberrant pour un programmeur, je n'en suis pas un!).

Ah les System.out.println(timeString et dCount), je les ai fait mais je ne l'ai pas sur moi, je vous les montrerai lundi :P

Mais ce qu'il se passe c'est que finalement toutes les cases de ma liste affichent la même valeur.
08/08/2015, 00h22
tchize_

De quelle liste? Il y a deux listes dans ton exemple.
08/08/2015, 10h28
professeur shadoko
j'a pas bien compris le problème mais pourquoi ne pas créer un objet "ad hoc"?
Code:

1 2 3 4 5 6 7 8 class Rapport { String time ; double count ; // constructeur // accesseurs // + un petit toString() pour faire bonne mesure }
et ensuite mettre dans ta liste (ou ton Map) des instances de ce type?

1 pièce(s) jointe(s)

Citation:

Envoyé par Cafeinoman

@Tchize_ Je te rassure, je ne le fais pas dans mon code... Promis j'arrête d'être inattentif.

Peux tu fournir une impression des valeurs de la liste après quelques enregistrements?

Pour te répondre un extrait de mon code et de ma console ;)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 public void takeBillet (int iEntranceIndex,int iBilletIndex){ lBillets.add(lLastElements.get(iEntranceIndex).giveBillet(iBilletIndex)); iBilletCharged++; //timeString1 = ""; int i=0; //dCount=dCounti; lCount.add(i, dCount); lTimeString.add(i,timeString1); //System.out.println(lCount.get(0)); System.out.println(lTimeString.get(0)); i++; try { age(); System.out.println(lTimeString.get(0)); } catch (NullPointerException e){ } }
C'est au moment ou l'action takeBillet() s'effectue que je veux relever le temps.

Voilà ce que j'obtiens sur la console avec ce code :
Pièce jointe 185007

On voit bien que le temps stocker dans ma liste continue à avancer ce que je souhaite éviter !

10/08/2015, 11h26
cos12
Citation:
Envoyé par professeur shadoko

j'a pas bien compris le problème mais pourquoi ne pas créer un objet "ad hoc"?

Code:

1 2 3 4 5 6 7 8 class Rapport { String time ; double count ; // constructeur // accesseurs // + un petit toString() pour faire bonne mesure }

et ensuite mettre dans ta liste (ou ton Map) des instances de ce type?
Quel est l'intérêt de faire une classe à part ?

Sinon je ne connaissais pas les Maps, mais je n'ai pas besoin de clé ;) .

Salut,

Sans un code complet, c'est très difficile de comprendre : et ce n'est pas la trace que tu indiques qui va nous aider. Là, tu nous montres un code qui insert au début de 2 listes, des valeurs provenant de 2 variables dont on ne sait rien (d'autre que quelque chose qu'on pourrait supposer au vu des autres bribes de codes dispensés), puis ça affiche la première donnée (donc celle qu'on vient d'ajouter) d'une des 2 listes. Vu le résultat de la trace, il semble que tu aies déplacé la déclaration de timeString hors de la méthode, dans la classe, et donc que timeString cumule les différents mesures de dCount (et qu'on voit bien évoluer d'ailleurs). Les premières traces venant probablement d'ailleurs, peut-être d'un moment ou dcount ne varie pas et timeString est réinitialisé. On ne peut pas te donner de réponse précise tant q'on est obligé de faire des hypothèses et suppositions.

Fais un snippet qui reproduit la partie pertinente de ton code et reproduit ton comportement.

Par ailleurs, ta fonction de calcul de timeString est bien compliquée, et étrange en plus. La simplifier devrait aider à la compréhension du problème.
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 Snippet { public static void main(String[] args) throws InterruptedException { List<String> nombres = new ArrayList<>(); for(int i=0; i<=3600; i++) { nombres.add( 0, toString(i)); System.out.println(nombres.get(0)); } System.out.println("La liste complète : "); System.out.println(nombres); } public static String toString(double dCount) { final int h = (int)(dCount/3600); double s = (dCount - h*3600); final int m = (int)(s/60); s -= m*60; return String.format("%02d:%02d:%02d", h,m,(int)s); } }
Si j'exécute ça, j'obtiens bien ce que je m'attends à obtenir :
00:00:00
00:00:01
00:00:02
00:00:03
00:00:04
[...]
00:45:39
00:45:40
00:45:41
00:45:42
[...]
00:59:57
00:59:58
00:59:59
01:00:00
La liste complète : 
[01:00:00, 00:59:59, 00:59:58, [...], 00:00:04, 00:00:03, 00:00:02, 00:00:01, 00:00:00]

Salut :) ,

Je suis bien d'accord avec toi pour la construction du temps, cela me paraît inutilement complexe, le problème est que timeStrng est réutilisé dans de nombreuses classes, donc changer sa définition est risqué, mais je vais essayer.
Voilà la classe en entier:

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
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
package element;
 
import general.Billet;
import general.Simulation;
import gui.MainFrame;
 
import java.awt.Color;
import java.awt.Graphics;
import java.io.Serializable;
import java.util.LinkedList;
 
 
public class Element implements Serializable  {
 
	protected static final long serialVersionUID = 1L;
	protected double dWorkingTime=0;
	protected double dWaitingTime=0.001;
	protected LinkedList<Element> lNextElements ; 	// list containing the elements placed after the element you are looking at
	protected LinkedList<Element> lLastElements;  	// list containing the elements placed before the element you are looking at
	protected LinkedList<Billet> lBillets;
	protected double dPosY;
	protected double dPosX;
	protected double dLength;
	protected String sName;
	protected int iBilletCharged=0;
	protected double dCount;
	protected int iStrand=-1; 						// When not defined =-1 (not always defined in constructor because not always useful)
	protected boolean bMarkingInTC=false; 			// When a Marking Machine is in a transfer car:true
	protected boolean bMarkingWithWei=false;		// When a Marking Machine is on the same roller table as a WeighingM:true
	private MainFrame mFrame;
	private String timeString1="";
	private boolean bRun=true;
	private double dSimulationCycleTime = 0.1;
	//private double dCount1;
	private LinkedList<Double> lCount = new LinkedList<Double>();
	private LinkedList<String> lTimeString = new LinkedList<String>();
 
 
 
	public Element(String sNameP,double dPosXP,double dPosYP,double dLengthP){
		dPosY=dPosYP;
		dPosX=dPosXP;
		dLength=dLengthP;
		lNextElements=new LinkedList<Element>();
		lLastElements=new LinkedList<Element>();
		lBillets = new LinkedList<Billet>();
		sName=sNameP;
 
	}
 
	public Element() {
		// TODO Auto-generated constructor stub
	}
 
	public void age(){
 
 
		while (bRun) {
 
			if ((int) (dCount / 3600) < 10) {
				timeString1 = timeString1 + "0" + (int) (dCount / 3600) + ":";
 
			} else {
				timeString1 = timeString1 + (int) (dCount / 3600) + ":";
 
			}
			if ((int) ((dCount - (int) (dCount / 3600) * 3600) / 60) < 10) {
				timeString1 = timeString1 + "0" + (int) ((dCount - (int) (dCount / 3600) * 3600) / 60) + ":";
 
			} else {
				timeString1 = timeString1 + (int) ((dCount - (int) (dCount / 3600) * 3600) / 60) + ":";
 
			}
			if ((int) (dCount - 60 * (int) (dCount / 60)) < 10) {
				timeString1 = timeString1 + "0" + (int) (dCount - 60 * (int) (dCount / 60));
 
			} else {
				timeString1 = timeString1 + (int) (dCount - 60 * (int) (dCount / 60));
 
			}
			//System.out.println(timeString1);
			mFrame.getJpCommandSim().getJlAge().setText(timeString1);
 
			dCount = dCount + dSimulationCycleTime;
			}
 
			//mFrame.getJpCommandSim().updateUI();// Refresh Panel to see all the changes
 
 
	}
 
 
 
 
	public boolean isFree (){
		return lBillets.isEmpty();
	}
	public boolean billetReady(int iIndex1,int iIndex2){
		return false;
	}
	public void simulationCycle(double dTime){
	}
 
 
	public void paint(Graphics g,int iDecX,int iDecY,int k){
		g.setColor(Color.gray);
		g.fillRect((int)(iDecX-(dPosX/k)), (int)(iDecY+(dPosY/k)), (int)(dLength/k), 4);
	}
 
 
	public void addNextElement(Element e){
		lNextElements.add( e);
	}
 
	public void addLastElement(Element e){
		lLastElements.add(e);
	}
 
	public void addLastElement(Element e,int i){
		if (i<lLastElements.size()){
			lLastElements.add(i,e);
		}else lLastElements.add(e);
	}
 
	public void removeLastElement(int i){
		lLastElements.remove(i);
	}
 
	public void removeNextElement(int i){
		lNextElements.remove(i);
	}
 
	public void takeBillet (int iEntranceIndex,int iBilletIndex){
		lBillets.add(lLastElements.get(iEntranceIndex).giveBillet(iBilletIndex));
		iBilletCharged++;
		int i=0;
		//dCount=dCounti;
		lCount.add(i, dCount);
		lTimeString.add(i,timeString1);
		System.out.println(lTimeString.get(0));
 
 
		i++;
		try {
			age();
			System.out.println(lTimeString.get(0));
		}
 
	catch (NullPointerException e){
 
	}
		}
 
	public Billet giveBillet (int iBilletIndex){
		Billet b;
			b=lBillets.get(iBilletIndex);
			lBillets.remove(iBilletIndex);
			iBilletCharged--;
		return b;
	}
 
	public void reset(){
		lBillets.clear();
		iBilletCharged=0;
		dCount=0;
	}
 
	/*
	 * Getter and setter
	 */
 
	public double getdCount() {
		return dCount;
	}
	public void setdCount(double dCount) {
		this.dCount = dCount;
	}
	public double getPosY (){
		return dPosY;
	}
	public double getPosX (){
		return dPosX;
	}
	public double getLength(){
		return dLength;
	}
	public String getName(){
		return sName;
	}
	public LinkedList<Billet> getlBillets() {
		return lBillets;
	}
	public void setlBillets(LinkedList<Billet> lBillets) {
		this.lBillets = lBillets;
	}
	public void setPosY(double dPosY) {
		this.dPosY = dPosY;
	}
	public void setPosX(double dPosX) {
		this.dPosX = dPosX;
	}
	public LinkedList<Element> getlNextElements() {
		return lNextElements;
	}
	public void setlNextElements(LinkedList<Element> lNextElements) {
		this.lNextElements = lNextElements;
	}
	public LinkedList<Element> getlLastElements() {
		return lLastElements;
	}
	public void setlLastElements(LinkedList<Element> lLastElements) {
		this.lLastElements = lLastElements;
	}
	public double getWorkproportion(){
		 return dWorkingTime/(dWaitingTime+dWorkingTime);
	}
	public int getiBilletCharged() {
		return iBilletCharged;
	}
	public void setiBilletCharged(int iBilletCharged) {
		this.iBilletCharged = iBilletCharged;
	}
 
	public void setStrand(int iStrand){
		this.iStrand=iStrand;
	}
 
	public void setbMarkingInTC(boolean bMarkingInTC) {
		this.bMarkingInTC = bMarkingInTC;
	}
 
	public boolean isbMarkingInTC() {
		return bMarkingInTC;
	}
 
	public void setbMarkingWithWei(boolean bMarkingWithWei) {
		this.bMarkingWithWei = bMarkingWithWei;
	}
 
	public boolean isbMarkingWithWei() {
		return bMarkingWithWei;
	}
}

Et une partie de la classe où timeString est vraiment définie, je ne mets pas tout, il y a 650 lignes...:aie:

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
90
91
92
93
94
95
96
97
 
private boolean bRun;
	private transient Thread th;
	private double dCount = 0;
	private Hashtable<String, Element> Elements;
	private LinkedList<Billet> bDecompte;
	private MainFrame mFrame;
	private int iCollisionCase = 0;
	private LinkedList<Element> lCut = new LinkedList<Element>();
 
	private double dSimulationCycleTime = 0.1;
	private double dSimulationTimeOffline = 3600 * 48;
	private double dTimeBeforeCollision = 3600 * 0.25;
 
//Un peu plus loin
 
while (e.hasMoreElements()) {
				Element a = e.nextElement();
				a.simulationCycle(dSimulationCycleTime); // make every elements do its cycle
			}
 
			// Update of time...............................................................................
			String timeString = "";
			if ((int) (dCount / 3600) < 10) {
				timeString = timeString + "0" + (int) (dCount / 3600) + ":";
				//System.out.println(timeString + "0" + (int) (dCount / 3600));
			} else {
				timeString = timeString + (int) (dCount / 3600) + ":";
				//System.out.println(timeString + (int) (dCount / 3600)); naffiche rien
			}
			if ((int) ((dCount - (int) (dCount / 3600) * 3600) / 60) < 10) {
				timeString = timeString + "0" + (int) ((dCount - (int) (dCount / 3600) * 3600) / 60) + ":";
				//System.out.println(timeString + "0" + (int) ((dCount - (int) (dCount / 3600) * 3600) / 60)); //affiche min et sec val identique (pas les dizaines)
			} else {
				timeString = timeString + (int) ((dCount - (int) (dCount / 3600) * 3600) / 60) + ":";
				//System.out.println( timeString + (int) ((dCount - (int) (dCount / 3600) * 3600) / 60));de meme mais a partir des dizaine
			}
			if ((int) (dCount - 60 * (int) (dCount / 60)) < 10) {
				timeString = timeString + "0" + (int) (dCount - 60 * (int) (dCount / 60));
				//System.out.println(timeString + "0" + (int) (dCount - 60 * (int) (dCount / 60)));//affiche la valeur exacte au centieme pres meme dizaine
			} else {
				timeString = timeString + (int) (dCount - 60 * (int) (dCount / 60));
				//System.out.println(timeString + (int) (dCount - 60 * (int) (dCount / 60)));//de meme
			}
 
			mFrame.getJpCommandSim().getJlTime().setText(timeString);
 
 
			dCount = dCount + dSimulationCycleTime;
			// Update the production data...............................................................................
			int i = 0;
			//int iBilletCharged = Element.getiBilletCharged();
			double dTProd = 0;
			while (Elements.containsKey("cut" + i)) {
				dTProd = dTProd + ((Cutter) Elements.get("cut" + i)).getdTonsProd();
 
				//mFrame.getJpCommandSim().getJlAge().setText(timeString);
				i++;
 
			/*	if (iBilletCharged >= 8){
					mFrame.getJpCommandSim().getJlAge().setText(timeString);
					//AgeList.add(timeString);
										//( mFrame.getJpCommandSim().getJlAge()).setText("");
 
 
				}*/
			}
			mFrame.getJpCommandSim().getJlTonsProduced().setText("" + ((int) (dTProd)));
 
 
			mFrame.getJpCommandSim().getJlProductivity().setText("" + (int) (dTProd * 3600 / dCount));
			mFrame.getJpCommandSim().getJlTotCuttingB().setText("" + (bDecompte.size() - i));// i=nbr of strand
			i = 0;
			while (Elements.containsKey("TC" + i)) {
 
				lTCCycleT.get(i).setText("" + (int) (((CrossTransferCar) Elements.get("TC" + i)).getdCycleTime() + 0.5));
				lTCInHomeT.get(i).setText("" + (int) (((CrossTransferCar) Elements.get("TC" + i)).getdTimeInHome() + 0.5));
 
				i++;
 
			}
 
			mFrame.getJpCommandSim().updateUI();// Refresh Panel to see all the changes
 
			// Make a break in the thread depending of scale Speed Command..........................................
			try {
				/*
				 * Thread.sleep((int) (101 - mFrame.getJpCommandSim().getJsSimSpeed().getValue())); } catch (InterruptedException e1) {
				 * e1.printStackTrace();it was too slow
				 */
 
				Thread.sleep((int) (170 / mFrame.getJpCommandSim().getJsSimSpeed().getValue())); // inverse function sleep
			} catch (InterruptedException e1) {
				e1.printStackTrace();
 
			}
		}

Bah, voilà, avec tout le code, tout s'éclaire : tu as 2 classes, avec chacune des variables dCount et timeString1, donc toute action faite dans une classe n'a aucune répercussion sur l'autre. Les valeurs qui sont stockées dans les listes sont faites dans une méthode de la classe Element, avec les variables de la classe Element. Tu as bien prévu un setter pour injecter dCount, mais je ne vois nulle part où il est appelé (peut-être fait-il partie des lignes que tu as supprimées, mais cela peut expliquer pour la progression n'est pas celle que tu désires.

C'est un peu comme si tu avais écrit :
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 public class Exemple { public static void main(String[] args) { Exemple1 exemple1 = new Exemple1(); Exemple2 exemple2 = new Exemple2(); for(int i=0; i<10; i++) { exemple2.run(); exemple1.print(); } } public static class Exemple1 { private int dcount; public void setCount(int dcount) { this.dcount=dcount; } public void print() { System.out.println(dcount); } } public static class Exemple2 { private int dcount; public void run() { dcount++; } public int getCount() { return dcount; } public void print() { System.out.println(dcount); } } }
Ça n'affiche que des 0, même si on incrémente bien dcount de exemple2. Mais on affiche celui de exemple1, qui lui n'est jamais incrémenté.

Change main() en :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public static void main(String[] args) { Exemple1 exemple1 = new Exemple1(); Exemple2 exemple2 = new Exemple2(); for(int i=0; i<10; i++) { exemple2.run(); exemple1.setCount(exemple2.getCount()); exemple1.print(); } }
Et là, tu vois s'afficher : 1 2 3 4 5 6 7 8 9 10...

Lorsqu'on a des valeurs à traiter et à afficher, il vaut mieux toujours ne pas multiplier leur stockage dans des classes différentes : il vaut mieux les partager. Sinon, il faut synchroniser leur valeur, et, non seulement ça peut être compliqué, mais en plus, c'est assez facile d'oublier de le faire.
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 public class Exemple { public static void main(String[] args) { Model model = new Model(); Exemple1 exemple1 = new Exemple1(model); Exemple2 exemple2 = new Exemple2(model); for(int i=0; i<10; i++) { exemple2.run(); exemple1.print(); } } public static class Model { private int dcount; public void setCount(int dcount) { this.dcount=dcount; } public int getCount() { return dcount; } } public static class Exemple1 { private final Model model; public Exemple1(Model model) { this.model=model; } public void print() { System.out.println(model.getCount()); } } public static class Exemple2 { private final Model model; public Exemple2(Model model) { this.model=model; } public void run() { model.setCount(model.getCount()+1); } public void print() { System.out.println(model.getCount()); } } }
Ici, la méthode run() de Exemple2 modifie la même donnée que celle que Exemple1 (ou Exemple2) affiche. Plus de besoin d'avoir à penser à synchroniser les valeurs dans les 2 classes : la donnée existe une seule fois et est utilisée à plusieurs endroits (Mais on peut quand même avoir plusieurs triplets Model/Exemple1/Exemple2 avec chacun leur propre valeur de dcount si nécessaire.