objet "this" mis à jour par une méthode sans raison
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:
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:
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:
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.
:roll:
quelques infos supplémentaires
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:
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:
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???
