Discussion :

[Macomoul]

Bonjour à vous,
Merci de m'aider à comprendre le problème ci dessous qui me laisse perplexe:

Le problème est le suivant:
J'ai une classe nommée Coup déclarée comme ci dessous:

Code :

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

1
2
3
4
5
6
7
 
class Coup {
	Mouvement_unit_pièce mouvement[];
	Pièce pièce_mvt;
	Position_damier damier;
	int nbre_pièces_mangées;  
	boolean dame;

Mouvement_unit_pièce est une autre classe définit par ailleurs dans mon programme.
la classe Coup possède une méthode:

Coup ajouter_mouvement(Mouvement_unit_pièce nouveau_mouvement)

Cette méthode a pour objectif de retourner un objet coup dont le tableau mouvement aura été enrichi du "nouveau_mouvement" en paramètre de la méthode.

Mon problème est que la méthode, non seulement fait ce qui est décrit ci dessus, mais met aussi à jour l'objet "this" auquel s'applique la méthode (ce qui n'est pas du tout l'objectif cherché.

Ci dessous un exemple d'appel de la méthode:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
 public static void main(String[] args) 
   {
...
 Mouvement_unit_pièce mouv_test_ajout; // mouvement unitaire utilisé dans le test de la méthode d'ajout mouvement
 Coup coup_test_ajout, coup_test_ajout2;// Coups utilisés pour le test de la méthode d'ajout mouvement
...
coup_test_ajout2 = coup_test_ajout.ajouter_mouvement(mouv_test_ajout);
...
}

Donc, le souçi comme je l'ai dit, c'est que à la sortie de la méthode, non seulement coup_test_ajout2 possède le nouveau mouvement dans son tableau de mouvement , mais aussi coup_test_ajout. Et là, c'est le drame...

Voici donc ci-dessous la méthode dont je parle:

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
 
	Coup ajouter_mouvement(Mouvement_unit_pièce nouveau_mouvement)
	 {
		Coup coup_sortie;
		coup_sortie = new Coup();// Initialisation du coup qu'on renverra en sortie
 
		coup_sortie.mouvement = new Mouvement_unit_pièce[21];
		coup_sortie.mouvement = mouvement;
		coup_sortie.pièce_mvt = pièce_mvt;
		coup_sortie.damier=damier;
		coup_sortie.nbre_pièces_mangées = nbre_pièces_mangées;
		coup_sortie.dame = dame;
 
 		for (int i=1; i<=21; i++) // On parcours la liste des mouvements de this et lorsqu'on tombe sur un null, on y ajoute le mouvement en entrée
		{
			if (coup_sortie.mouvement[i]==null)
			{				coup_sortie.mouvement[i]= new Mouvement_unit_pièce();// on initialise le nouveau mouvement
	coup_sortie.mouvement[i]= nouveau_mouvement;
 
// C'est ici que le drame se produit: Ici, sans que je comprenne pourquoi, this.mouvement[i] est aussi mis à jour sans que je ne lui demande rien.
 
                                     break;
			}
		}
 
 
		return coup_sortie;
	}

J'éspère avoir été à peu près clair et je vous remercie d'avance de m'aider dans ce problème.

[Lidden]

Bonsoir,

tout d'abord, je te conseille d'aller voir les conventions de nommage, parce que les noms à rallonge avec des "_" dans tous les sens

Sinon, tu as déjà une erreur dans ton exemple il me semble :

Code :

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

1
2
 
coup_test_ajout2 = coup_test_ajout.ajouter_mouvement(mouv_test_ajout);

Tu appliques la méthode ajouter_mouvement à l'objet coup_test_ajout AVANT de le recopier dans coup_test_ajout2, donc oui, forcément, il est modifié


En effet, pour ne modifier que coup_test_ajout2, il faudrait faire cela :

Code :

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

1
2
3
 
coup_test_ajout2 = coup_test_ajout;
coup_test_ajout2.ajouter_mouvement(mouv_test_ajout);

[floflo_2006]

tout d'abord, je te conseille d'aller voir les conventions de nommage, parce que les noms à rallonge avec des "_" dans tous les sens

+1

Tu appliques la méthode ajouter_mouvement à l'objet coup_test_ajout AVANT de le recopier dans coup_test_ajout2, donc oui, forcément, il est modifié

Non.

Si on regarde la méthode, on s'aperçoit qu'à aucun moment on ne modifie les attribut de this : on travail tout au long de la méthode sur l'objet coup_sortie.

Je ne vois rien dans cette méthode qui puisse modifier this. Es-tu sûr que ton objet est modifié ici :

Code :

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

coup_test_ajout2 = coup_test_ajout.ajouter_mouvement(mouv_test_ajout);

Remarque :

Code :

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

1
2
coup_sortie.mouvement[i]= new Mouvement_unit_pièce();
coup_sortie.mouvement[i]= nouveau_mouvement;

Il est inutile de créer une nouvelle instance si tu lui affectes une valeur juste après.

[Macomoul]

Merci à vous pour vos réponses,
D'abord, effectivement, je vais essayer d'être un peu moins bavard dans mes noms de variable et classe.
Pour ce qui de créer une nouvelle instance juste avant de lui affecter une valeur, merci pour l'info: Effectivement, cela marche tout aussi bien sans.

Pour mon problème de fond voici quelques infos :

J'ajoute les quelques lignes ci dessous dans la méthode "ajouter_mouvement" afin de lire le mouvement this avant et après la commande que je suspecte.

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
 
Coup ajouter_mouvement(Mouvement_unit_pièce nouveau_mouvement)
 {
		Coup coup_sortie;
		coup_sortie = new Coup();// Initialisation du coup qu'on renverra en sortie
 
		coup_sortie.mouvement = new Mouvement_unit_pièce[21];	// On initialise coup avec les données du coup en entrée: this
 
		coup_sortie.mouvement = mouvement;
		coup_sortie.pièce_mvt = pièce_mvt;
		coup_sortie.damier=damier;
		coup_sortie.nbre_pièces_mangées = nbre_pièces_mangées;
		coup_sortie.dame = dame;
		for (int i=1; i<=21; i++) // On parcours la liste des mouvements de this et lorsqu'on tombe sur un null, on y ajoute le mouvement en entrée
		{
			if (coup_sortie.mouvement[i]==null)
			{
		/*******************************************************************************
                 *****************************test************************************************/	
		out.println("test d'affichage de this avant affectation coup_sortie.mouvement[i]");//test
 
		for (int t=1; t<=4; t++)
		{
			if (this.mouvement[t]!=null)//test
			{
				out.print("test this.mouvement ["+t+"] dans ajouter mouvement");
				this.mouvement[t].affiche_mvt();//test
			}	
		}
 
		/*******************************************************************************
                 *****************************test**********************************************/
				coup_sortie.mouvement[i]= nouveau_mouvement;
		/*******************************************************************************
                 *****************************test************************************************/	
		out.println("test d'affichage de this après affectation coup_sortie.mouvement[i]");//test
		for (int t=1; t<=4; t++)
		{
			if (this.mouvement[t]!=null)//test
			{
				out.print("test this.mouvement ["+t+"] dans ajouter mouvement");
				this.mouvement[t].affiche_mvt();//test
			}	
		}
 
		/*******************************************************************************
                 *****************************test************************************************/		
 
 
 
				if (nouveau_mouvement.dégustation==true)   //On ajoute 1 au nombre de pièces mangées dans le coup si dégustation est à true 
				{
					coup_sortie.nbre_pièces_mangées+=1;
				}
				break;
			}
		}
 
 
		return coup_sortie;
	}

J'utilise ici une méthode affiche_mvt qui me permet d'afficher le contenu d'un mouvement (sa partie essentielle au moins).

Le résultat obtenu est celui ci :

Code :

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

1
2
3
4
 
test d'affichage de this avant affectation coup_sortie.mouvement[i]
test d'affichage de this après affectation coup_sortie.mouvement[i]
test this.mouvement [1] dans ajouter mouvementPièce blanc (6,7) va de 33 à 11 Mange :false

Avant l'ajout "nouveau_mouvement" au tableau "coup_sortie.mouvement[i]", le tableau this.mouvement[] est vide. Après l'ajout, il y a une valeur this.mouvement [1]. Donc, c'est bien ici que se pose le problème.

Etrange non???

[floflo_2006]

Code :

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

1
2
coup_sortie.mouvement = new Mouvement_unit_pièce[21];
coup_sortie.mouvement = mouvement;

C'est quoi ça ???


Tu crées un nouveau tableau puis après tu lui affectes le tableau de this. Voilà pourquoi this est modifié.

[Macomoul]

Bonsoir floflo,
Merci de t'intéresser à mon cas.

Code :
coup_sortie.mouvement = new Mouvement_unit_pièce[21];
coup_sortie.mouvement = mouvement;C'est quoi ça ???


Tu crées un nouveau tableau puis après tu lui affectes le tableau de this. Voilà pourquoi this est modifié.

Pour le coup du création d'un nouveau tableau puis affectation d'une valeur, je pense que c'est un peu dans la même veine que ce que tu m'as fait remarquer auparavent. Je n'ai pas bien eu le temps de tout remettre en ordre... Cependant, petite question à ce sujet: Si je met directement coup_sortie.mouvement = mouvement; est-ce que la taille du tableau coup_sortie.mouvement sera la me^me que celle de this.mouvement (à savoir 21)?

Pour le coup_sortie.mouvement = mouvement;C'est quoi ça ???
C'est simplement qu'au début de la méthode, j'initialise les mouvements de this vers coup_sortie. Après cela, je rajoute le nouveau_mouvement en paramètre à coup_sortie. A priori, je ne pense pas que cela ait un impact sur this, ou alors, il y a une logique de plus que je n'ai pas bien comprise dans Java...