probleme de conception pour un Conway's life

Version imprimable

06/12/2008, 15h03
areuh_fr

probleme de conception pour un Conway's life

Bonjour,

Voilà, j'essaye de programmer un Consway' s Life mais j'ai tout le mal du monde a concevoir le fonctionnement du programme.

Pour le moment, je me suis attaqué a l'interface, voici ce que j'ai fait

une classe MainWin qui herite de JFrame avec
- BoderLayout
- North, South, East, West sont des JPanel classiques. South contient un JButton pour demarrer l'appli.

une classe Cellule avec
- un constructeur minimaliste, avec juste 3 variables
-> int posX;
-> int posY;
-> boolean vivante= false;

- une methode paint qui dessine un rectangle de 5 par 5, couleur rouge ou noire selon que la cellule est vivante ou non

une classe MondeCellule qui herite de JPanel avec un constructeur minimaliste. (rien de declaré pour le moment)

Je mets une instance de MondeCellule dans MainWin.

C'est tout pour le moment car je n'arrive pas a attaquer le probleme.
--------------------------
Apres lecture d'une page: http://www.mines.inpl-nancy.fr/~tiss...t/jeu_vie.html (j'ai prefere ne pas regarder le code) qui dit:
1. une classe pour l'espace, le plan composé de cellules,
2. une classe pour les objets cellules.

Les fonctionnalités du plan, la classe "espace cellulaire" sont de :

* encapsuler le tableau de cellules,
* créer une population initiale, en créant ses objets "cellule",
* faire tourner l'algorithme, c'est à dire boucler sur
1. afficher l'automate,
2. calculer la génération suivante ;
* et de gérer l'attirail technique nécessaire au graphisme en Java et au séquencement des affichages.

Cette classe accède aux cellules par les méthodes correspondant aux fonctionnalités de la classe "cellule" :

* encapsuler les données sur la position géographique de la cellule et son état (occupé ou vide),
* initialiser un objet cellule,
* rendre occupée une cellule qui était vide,
* savoir si une cellule est vide ou occupée,
* calculer l'état à la génération suivante d'une cellule en fonction de son état et de son nombre de voisins,
* mémoriser l'état d'une cellule pour que les calculs de changement de génération se fassent sur l'ancien état des cellules tout en créant le nouveau tableau des états,
* et l'attirail technique pour afficher graphiquement la cellule.
--------------------------

je m'apercois qu'il me faut un tableau bidimensionnel (je ne souhaite pas pour le moment travailler avec des Vector ou LinkedList, etc, etc). Dc oui
pour le tableau bidimensionnel, pas de probleme (enfin pas trop, je pense).

mais j'ai pas mal de questions:
1°: dans ma classe MondeCellule, pour afficher mes cellules, il me faut un LayoutManager??? je pense, oui, dc un simple GridLayout
2°: la methode de recherche proprement dite.
il faut bien qu'une Celllule interroge ses voisines pour savoir si elle doit vivre ou non mais dans une simple grille, y'a t'il differents types de voisines?
je m'explique
les Cellules au centre, ont 8 voisines
celles sur les cotes ont seulement 5 voisines
celles ds les coins ont 3 voisines
en plus suivant ou se situe ma Cellule, les voisines ne sont pas placées au meme endroit
si la Cellule est en bas alors on a:
xxx
x?x
-----

Si la Cellule est en haut c'est le contraire:
-----
x?x
xxx

et ainsi de suite

est ce que je dois faire differentes methodes selon la place qu'occupe une Cellule?

Enfin bref comme vous le voyez, je patauge, je patauge.

Pourriez vous m'indiquer des pistes, des... conseils, je demande pas le code, juste une aide à la conception.

En vous remerciant
areuh

Encore moi,

Bon j'ai fait qque chose mais evidemment, ca marche pas.

Pour le moment, j'affiche dans la console et je pars avec comme objectif de faire un clignoteur simple en definissant moi meme mes 3 1° Cellules vivantes

Voici le code de la classe MondeCellule.java

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
 
import javax.swing.JPanel;
 
import java.awt.GridLayout;
 
public class MondeCellule extends JPanel {
 
	//------------------------------------------------------------------------------------------------------------
	//------------------------------------------------------------------------------------------------------------
	// variables
 
	// CONSTANTE: cote du GridLayout
	int COTE= 10;
 
	// nbre de generation au debut de la simulation
	int generation= 0;
 
	Cellule[][] tabGenerationN= new Cellule[this.COTE][this.COTE];
	Cellule[][] tabGenerationNMoinsUn= new Cellule[this.COTE][this.COTE];
 
	//------------------------------------------------------------------------------------------------------------
	//------------------------------------------------------------------------------------------------------------
	// objets crees/importes
 
	//------------------------------------------------------------------------------------------------------------
	//------------------------------------------------------------------------------------------------------------
	// constructeur
	MondeCellule() {
		this.setLayout(new GridLayout(this.COTE, this.COTE));
		//--------------------------------------------------------------------------------------------------------
		initCellules();
 
		// creer la generation initiale
		// this.tabGenerationN[3][0].etat= false; // n'est pas pris en compte ds la recherche
		// this.tabGenerationN[3][1].etat= true;
		this.tabGenerationN[3][2].etat= true;
		this.tabGenerationN[3][3].etat= true;
		this.tabGenerationN[3][4].etat= true;
		/*
		this.tabGenerationN[3][5].etat= true;
		this.tabGenerationN[3][6].etat= true;
		this.tabGenerationN[3][7].etat= true;
		this.tabGenerationN[3][8].etat= true;
		this.tabGenerationN[3][9].etat= false; // n'est pas pris en compte ds la recherche
		*/
		/*
		this.tabGenerationN[0][3].etat= false; // n'est pas pris en compte ds la recherche
		this.tabGenerationN[1][3].etat= true;
		this.tabGenerationN[2][3].etat= true;
		this.tabGenerationN[3][3].etat= true;
		this.tabGenerationN[4][3].etat= true;
		this.tabGenerationN[5][3].etat= true;
		this.tabGenerationN[6][3].etat= true;
		this.tabGenerationN[7][3].etat= true;
		this.tabGenerationN[8][3].etat= false; // n'est pas pris en compte ds la recherche
		this.tabGenerationN[9][3].etat= false; // n'est pas pris en compte ds la recherche
		*/
 
		// afficher this.tabGenerationN
		this.afficheGenerationN();
 
	}
 
	//------------------------------------------------------------------------------------------------------------
	//------------------------------------------------------------------------------------------------------------
	// getters
 
	//------------------------------------------------------------------------------------------------------------
	//------------------------------------------------------------------------------------------------------------
	// setters
 
	//------------------------------------------------------------------------------------------------------------
	//------------------------------------------------------------------------------------------------------------
	// methodes de classe
	public void initCellules() {
		for(int i= 0; i< this.tabGenerationN.length; i++) {
			for(int j= 0; j< this.tabGenerationN.length; j++) {
				this.tabGenerationN[i][j]= new Cellule();
				this.add(this.tabGenerationN[i][j]);
			}
		}
	}
 
	public void rechercheVoisines() {
		for(int i= 1; i<= (this.tabGenerationN.length- 2); i++) {
			for (int j= 1; j<= (this.tabGenerationN.length- 2); j++) {
 
				if(this.tabGenerationNMoinsUn[i- 1][j- 1].etat== true) {
					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
				}
				if(this.tabGenerationNMoinsUn[i][j- 1].etat== true) {
					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
				}
				if(this.tabGenerationNMoinsUn[i+ 1][j- 1].etat== true) {
					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
				}
				if(this.tabGenerationNMoinsUn[i- 1][j].etat== true) {
					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
				}
				if(this.tabGenerationNMoinsUn[i+ 1][j].etat== true) {
					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
				}
				if (this.tabGenerationNMoinsUn[i- 1][j+ 1].etat== true) {
					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
				}
				if(this.tabGenerationNMoinsUn[i][j+ 1].etat== true) {
					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
				}
				if(this.tabGenerationNMoinsUn[i+ 1][j+ 1].etat== true) {
					this.tabGenerationN[i][j].nbreVoisinesVivantes++;
				}
 
				/*
				// affichage de MondeCellule ds la console
				// ATTENTION, si i= 0, 8 ou 9 et j= 0 ou 9, ce n'est pas pris en compte ds la recherche
				if(i< this.tabGenerationN.length- 2) {
					System.out.print(this.tabGenerationN[i][j].etat);
					if(j== this.tabGenerationN.length- 2) {
						System.out.println(" ");
					}
				}
				*/
 
			}
		}
	}
 
	public void copie() {
 
			// System.out.println("-----------------------------------");
			System.arraycopy(tabGenerationN, 0, tabGenerationNMoinsUn, 0, COTE);
 
			// affichage de this.tabGenerationNMoinsUn
			for(int i= 1; i<= (this.tabGenerationN.length- 2); i++) {
				for (int j= 1; j<= (this.tabGenerationN.length- 2); j++) {
					if(i< this.tabGenerationN.length- 2) {
						System.out.print(this.tabGenerationNMoinsUn[i][j].etat);
						if(j== this.tabGenerationN.length- 2) {
							System.out.println(" ");
						}
					}
				}
			}
 
			System.out.println("-----------------------------------");
		}
 
	public void update() {
		for(int i= 1; i<= (this.tabGenerationN.length- 2); i++) {
			for (int j= 1; j<= (this.tabGenerationN.length- 2); j++) {
				// naissance d'une Cellule: nbre de Cellules voisines vivantes= 3 et etat= false
				if(this.tabGenerationNMoinsUn[i][j].nbreVoisinesVivantes== 3 && this.tabGenerationNMoinsUn[i][j].etat== false) {
					this.tabGenerationN[i][j].etat= true;
				}
				// survie d'une Cellule: nbre de Cellules voisines vivantes= 2 ou 3 et etat= true
				if(this.tabGenerationNMoinsUn[i][j].nbreVoisinesVivantes== 2 && this.tabGenerationNMoinsUn[i][j].etat== true
						|| this.tabGenerationNMoinsUn[i][j].nbreVoisinesVivantes== 3 && this.tabGenerationNMoinsUn[i][j].etat== true) {
							this.tabGenerationN[i][j].etat= true;
				}
				// mort d'une Cellule:
				// etouffement: nbre de Cellules voisines vivantes >= 4
				// isolation: nbre de Cellules voisines vivantes <= 1
				// etat= true
				if(this.tabGenerationNMoinsUn[i][j].nbreVoisinesVivantes <= 1 && this.tabGenerationNMoinsUn[i][j].etat== true
						|| this.tabGenerationNMoinsUn[i][j].nbreVoisinesVivantes >= 4 && this.tabGenerationNMoinsUn[i][j].etat== true) {
							this.tabGenerationN[i][j].etat= false;
				}
			}
		}
	}
 
	public void afficheGenerationN() {
		System.out.println("-----------------------------------");
		if(this.generation== 0) {
			System.out.println("ancienne generation: "+ (this.generation- 1));
			this.copie();
			System.out.println("nouvelle generation: "+ this.generation);
			for(int i= 1; i<= (this.tabGenerationN.length- 2); i++) {
				for (int j= 1; j<= (this.tabGenerationN.length- 2); j++) {
					if(i< this.tabGenerationN.length- 2) {
						System.out.print(this.tabGenerationN[i][j].etat);
						if(j== this.tabGenerationN.length- 2) {
							System.out.println(" ");
						}
					}
				}
			}
		}
 
		if(this.generation > 0) {
			System.out.println("ancienne generation: "+ (this.generation- 1));
			this.copie();
			System.out.println("nouvelle generation: "+ this.generation);
			this.rechercheVoisines();
			this.update();
			for(int i= 1; i<= (this.tabGenerationN.length- 2); i++) {
				for (int j= 1; j<= (this.tabGenerationN.length- 2); j++) {
					if(i< this.tabGenerationN.length- 2) {
						System.out.print(this.tabGenerationN[i][j].etat);
						if(j== this.tabGenerationN.length- 2) {
							System.out.println(" ");
						}
					}
				}
			}
		}
		System.out.println("-----------------------------------");
	}
 
	public void clic() {
		this.generation ++;
		this.afficheGenerationN();
 
	}
}

Je trouve que c'est super bordelique, comme code, je m'y retrouve pas toujours avec ces boucles imbriquées.

Voici ce que j'obtiens ds la console (un simple affichage de tableaux boolean)
-----------------------------------
ancienne generation: -1
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsetruetruetruefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
-----------------------------------
nouvelle generation: 0
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsetruetruetruefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
-----------------------------------
-----------------------------------
ancienne generation: 0
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsetruetruetruefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
-----------------------------------
nouvelle generation: 1
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsetruefalsefalsefalsefalsefalse
falsefalsetruefalsefalsefalsefalsefalse
falsefalsetruefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
-----------------------------------
-----------------------------------
ancienne generation: 1
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsetruefalsefalsefalsefalsefalse
falsefalsetruefalsefalsefalsefalsefalse
falsefalsetruefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
-----------------------------------
nouvelle generation: 2
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
falsefalsefalsefalsefalsefalsefalsefalse
-----------------------------------

explication:
ancienne generation: -1, une copie du tableau nouvelle generation: 0 que j'initialise en dur dans le constructeur

nouvelle generation: 0, le tableau defini en dur ds le constructeur

ancienne generation: 0, de nouveau une copie du tableau que je definis ds le constructeur

nouvelle generation: 1, le programme defini correctement la nouvelle generation

ancienne generation: 1, le programme copie la nouvelle generation: 1

ensuite ca deconne puisque
nouvelle generation: 2, le programme ne definit pas a partir de ancienne generation: 1

Si vous pouviez m'expliquer ou je foire svp, je seche un peu là.

Merci bien
areuh

07/12/2008, 18h01
Tux++

Bonjour,

Je peux te donner le lien d'un conway life bien développé,

je peux comprendre que tu veuilles le dev. toi-même mais pourquoi ne pas partir de là? ;)

http://www.bitstorm.org/gameoflife/
07/12/2008, 18h11
areuh_fr

Salut tux++

j'espere que c'est pas bitstorm ton lien car le serveur met trop de temps a repondre... lol

Sinon, ouais, j'avoue, j'ai regardé le code de la page que j'ai donné + haut et je pensais sincerement avoir fait qque chose d'analogue mais non, c'est pas ça.

pfffff, put*** de programme, malgré tout, je continue!!!!

Merci pour l'adresse, je reessaierai (ca s'ecrit comme ça??) de temps en temps, histoire de savoir comment on fait.

a+
areuh

edit]
ok le lien fonctionne, merci
[/edit]
09/12/2008, 15h26
areuh_fr

re,

bon j'ai regardé... ca fait peur, j'ai une autre adresse qui donne aussi un UML avec la javadoc, je vais partir avec ceci:

http://gameoflife.free.fr/doc_fr.htm

moins de classe (deja que je m'y perds avec seulement 3) et surtout la javadoc

j'essaierai de poster regulierement (mais je suis pas pressé non plus).

Si tu (vous) veux (voulez) me filer un coup de main.

a+
areuh

salut,

bon je viens de faire les 2 classes qui, à mon avis sont les + simples
State
Cell

déja qques questions que je me pose
Dans ses constructeurs, les noms de leurs parametres sont les memes que les variables d'attribut
exemple avec la classe Cell
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 // variables public short row; public short col; public State state; // constructeurs public Cell(int row, int col) { } public Cell(int row, int col, State state) { }
personnellement, je les aurai différenciés (comme ce que j'ai vu dans tous les exemples adresses aux débutants).
exemple
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 // variables public short row; public short col; public State state; // constructeurs public Cell(int pRow, int pCol) { } public Cell(int pRow, int pCol, State pState) { }
et puis je fais la relation entre variables d'attribut et parametres des constructeurs
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 // variables public short row; public short col; public State state; // constructeurs public Cell(int pRow, int pCol) { this.row= pRow; this.col= pCol; } public Cell(int pRow, int pCol, State pState) { this.row= pRow; this.col= pCol; this.state= pState; }
le truc c'est que les variables d'attribut st de type short alors que les parametres sont de type int... alors ou je caste (faut que je cherche) ou je modifie le type des variables (ou des parametres)?

le cas se represente pour le setter setState(): l'affectation de la variable est sans effet (dixit Eclipse).

Derniere question en ce qui concerne le getter getPosition() qui retourne une valeur de type String. je n'ai aucune String dans la classe Cell, dc a mon avis , la methode doit recuperer indexState de la classe State?

Voilà pour ce post, je vais aller au plus simple:
- modifier le type de mes variables d'attribut
- faire les relations entre variables et parametres du constructeur (idem pour la methode setState())
- recuperer cette String indexState de la classe State.

Derniere question qui me turlupine mais c'est au niveau du diagramme, comment se fait il que sur certains noms de classe, il y ait (avec ou sans t?) des triangles d'avertissement?

Voili, voilou, si vous avez les réponses... merci bien
a+
areuh

10/12/2008, 12h46
Tux++
Bonjour,

en ce qui concerne les noms de variables, c'est une nomenclature fortement utilisée, elles se différencient par le fait qu'une correspond à l'instance de this et l'autre est un paramètre:
Code:

1 2 3 4 5 6 7 8 9 10 ... private int a; private int b; public void test(int a, int b){ this.a = a; this.b = b; }
Cela permets de s'y retrouver plus facilement pour un autre lecteur, ou une maintenance quelconque. Si on conseille au débutant l'inverse c'est pour éviter qu'ils ne s'emmêlent les pinceaux ;)

Pour ce qui concerne tes int->short, si tu es sur d'obtenir des short à chaque fois, tu peux caster, sinon tu dois tout déclarer en int.

Et j'ai pas trop compris ta 3eme question, manque de code ;) mais en tout cas rien ne t'empêche de rajouter des attributs dans des classes ;)
10/12/2008, 16h21
areuh_fr
Re,

t'as pas trop compris ma 3° question... Ah ouais, tu veux dire sans doute ma derniere question qui se trouve avant ma derniere question, celle concernant le getter getPosition()... et j'essaye d'apprendre a programmer... je suis pas sorti de l'auberge.

ok, dc dans son diagramme de la classe Cell, il declare une methode:
getPosition(): String
C'est dc une methode qui renvoie une variable de type String mais dans cette meme classe, dans les variables d'attribut, il n'a y aucune String de declarée.

En plus dans sa javadoc, on trouve ceci concernant cette methode:

[javadoc]
getPosition

public java.lang.String getPosition()

Get String Position. Like: '12/1'
[/javadoc]

je pense dc que sa methode getPosition() doit renvoyer la String déclarée dans sa classe State (indexState)
ce qui donne:
Code:

1 2 3 4 5 public String getPosition() { String position= state.getIndexState(); return position; }
Ton avis?

Sinon
- etant donné que je ne suis sur de rien, je mets tout en int (c'est plus simple)
- rajouter des attributs euh... ouais... mais non, je prefere essayer de suivre son diagramme. le reste, je verrai apres.

prochaine etape (sans doute ce we):
ecrire ses 2 classes algorithm, l'une hérite de l'autre
ecrire la classe States (faut que je vois les HashMap)
ecrire la classe Shape (faut que je vois les Hashtable)

a+
Merci pour l'aide.
areuh

Citation:

Envoyé par areuh_fr

le cas se represente pour le setter setState(): l'affectation de la variable est sans effet (dixit Eclipse).

Si tu voulais qu'on t'explique ton erreur, il vaudrait mieux poster ton code...
Cependant, je suppose que tu as du faire quelque chose dans ce genre :
Code:

1 2 3 4 5 public void setState(State state) { state = state; // la variable locale masque le champ de la classe du même nom // du coup cette instruction signifie : la variable locale prend la valeur d'elle-même... et donc l'affectation n'a pas d'effet }
Au lieu de :
Code:

1 2 3 4 public void setState(State state) { this.state = state; // il faut dire explicitement que c'est au champ de la classe (et non à la variable locale) qu'on affecte une valeur }
Ou encore :
Code:

1 2 3 4 public void setState(State s) { state = s; // on donne un nom différent au paramètre de la fonction : plus de problème ! "state" ne peut désigner que le champ de la classe... }
C'est exactement le même problème que celui que tu évoquais avec les noms des paramètres du constructeur : on peut prendre les mêmes noms de paramètres que ceux des champs de la classe, mais alors pour désigner les champs il faudra le faire explicitement avec this.nomDuChamp.

Citation:

Envoyé par areuh_fr

Derniere question qui me turlupine mais c'est au niveau du diagramme, comment se fait il que sur certains noms de classe, il y ait (avec ou sans t?) des triangles d'avertissement?

La signification de ces triangles dépend évidemment de l'outil qui a généré ce diagramme.
Cependant, comme toutes les icônes utilisées ressemblent fortement à celles d'Eclipse, je vais supposer qu'ils indiquent simplement la présence d'avertissements. L'auteur de la page web a du laisser dans son code quelques "maladresses" (intentionnelles dans le but de développements futurs, ou non) : importations de packages, déclarations de variables ou instructions inutiles. Eclipse signale ces "erreurs" (qui ne posent aucun problème en elles-même) par un triangle d'avertissement, qui ne signifie donc absolument rien du point de vue du diagramme de classe (quoique... cela peut signaler qu'un champ ou une méthode est en fait inutilisé et que tu n'as pas besoin de le reproduire... mais cela peut aussi signaler qu'un avertissement est présent à l'intérieur de la méthode, on ne peut pas savoir).