Passage par référence ne permet pas la sauvegarde

Bonjour à tous,

Je suis confronté à un problème avec le passage des paramètres par valeur et référence, j'ai lu qu'il ne pouvait y avoir que ces 2 types de passage en java : pour les variables primitives => par valeur et pour el reste (les objets) => par références.

Mais mon problème survient lors de la sauvgarde des objets...

Je prends un exemple pour y voir plus clair :

Je créer une classe Piece (d'un jeu d'echec) qui aura les champs suivants (je ne décrit pas les méthode) :

-> boolean estBlanc;
-> int type;
-> JPanel image;

Ensuite je créer une classe qui permet de faire la sauvegarde dans un fichier, et je créer la méthode suivante :
Code:

1 2 3 4 public void save(Piece unePiece) { // ici j'ajoute unePiece à une ArrayList qui est membre de la classe de sauvegarde }
vu que unePiece est passé par référence, ce n'est qu'un alias qui est sauvegardé dans l'ArrayList, donc quand je récupère la sauvegarde, je ne récupère que des valeurs nulls.

Même en faisant cela :
Code:

1 2 3 4 5 public void save(Piece unePiece) { Piece p = unePiece; // ici j'ajoute p à une ArrayList qui est membre de la classe de sauvegarde }
Cela ne fonctionne pas, car p est aussi un alias de unePiece.

Et je suis forcé de faire :
Code:

1 2 3 4 5 6 7 8 9 public void save(Piece unePiece) { Piece p = new Piece(); p.estBleu = unePiece.estBleu; p.type = unePiece.type; p.image = unePiece.image; // ici j'ajoute p à une ArrayList qui est membre de la classe de sauvegarde }
et là ça focntionne bien.

Donc ma question est simple, suis-je à chaque fois obligé de recopier chaque champ de ma classe pour pouvoir faire la sauvegarde, ou est ce qu'il existe un moyen plus rapide pour faire uen sauvegarde non pas de l'alias ou de la référence mais de l'objet en lui même.

Merci pour vos réponses et bravo à ceux qui se sont lancé dans cette lecture^^

Normalement tu ne devrais pas avoir ce problème, peut tu montrer ton code ?

Ta classe Piece implémente-t-elle bien l'interface Serializable ??

Le problème ne viens pas du serializable, vue que s'il fait :
Code:

1 2 3 4 5 6 7 8 9 public void save(Piece unePiece) { Piece p = new Piece(); p.estBleu = unePiece.estBleu; p.type = unePiece.type; p.image = unePiece.image; // ici j'ajoute p à une ArrayList qui est membre de la classe de sauvegarde }
l'ArrayList ne contient pas null alors que avec :
Code:

1 2 3 4 5 public void save(Piece unePiece) { // ici j'ajoute p à une ArrayList qui est membre de la classe de sauvegarde }
l'ArraytList vas contenir null.

Salut,

Je vois pas trop ce que tu entends par classe de sauvegarde mais j'ai une precision a propos des references. Java manipule les objets par reference et les primitives par valeur par contre les objets ne sont pas passes par reference ds une methode. Java passe la reference d'un objet par valeur.
Ainsi tu peux changer une variable d'un objet passer ds une methode mais tu ne pourra pas faire un echange d'objet telque:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 void echanger(String a, String b){ String temp=a; a=b; b=temp; } public static void main(String [] args){ String a="a"; String b="b"; System.out.println(a+" "+b); echanger(a,b); System.out.println(a+" "+b); }
Mathieu

Citation:

qui est membre de la classe de sauvegarde

ça veut dire quoi ça ???

Citation:

ici j'ajoute p à une ArrayList

montre comment tu fais

Citation:

l'ArraytList vas contenir null

c'est parce que l'argument est null lui aussi ou que tu t'y prends comme une pine.

--> affiche ton argument pour débugger.
--> Montre nous plus de code, on poura pas t'aider sinon.

Citation:

qui est membre de la classe de sauvegarde

=> la classe de sauvegarde a pour champ une ArrayList qui contient toutes les pièces.

Voici le code mais bon courage pour la lecture car en faites, dans mes explications, j'ai pas mal simplifié :

En faites, je sauvegarde les données d'une parties qui appartiennent à un objet d'une classe Plateau. La classe stockant toutes ces données se noment DonneesPartie, sachant que cette classe ne fait qu'isoler les données importantes à sauvegardé contenu dans l'objet de la classe Plateau.

Pourquoi est ce que je ne manipule pas directement les données depuis une objet de la classe DonneesPartie dans l'objet de la classe Plateau ? Ben parceque je fais des tests, mais cela ne change rien au problème.

La classe GestionSauvegarde va prendre de la classe Plateau les données qui identifie une partie à sauvegarder. Elle va ensuite les stockées dans un objet de la classe DonneesPartie. Cet objet va être ajouté à l'ArrayList, et cette ArrayList va être écrit dans le fichier.

Pour la lecture c'est simple, je récupère l'objet DonneesPartie dans l'ArrayList qui m'interesse pour uen partie donnée.

La classe qui gère les sauvegardes :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.io.*;
import javax.swing.JPanel;
import java.util.ArrayList;
 
public class GestionSauvegarde implements Serializable
{
	private File chFichier;		// Fichier de sauvegarde
 
	private ArrayList<DonneesPartie> chListeParties;
 
    public GestionSauvegarde() 
    {
		try
		{
			chFichier = new File("sauvegardes.dat");
			chListeParties = new ArrayList<DonneesPartie>();
		}
		catch (NullPointerException parException)
		{
			System.err.println("Problème lors de l'instanciation du fichier des sauvegardes.");
			System.err.println(parException);
		}
    }

Toujours dans cette classe, les méthodes qui font la sauvegarde & écrivent dans le fichier :

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
	public void sauvegarder(Plateau parPartie)
	{
		DonneesPartie maPartie = new DonneesPartie();

		maPartie.setNom(parPartie.getNom());
		for(int i=0 ; i<=Plateau.largeur-1 ; i++)
		{
			for(int j=0 ; j<=Plateau.longueur-1 ; j++)
			{
				maPartie.setPieces(parPartie.getPieces(i,j), i, j);
				maPartie.setCases(parPartie.getCases(i,j), i, j);
			}
		}
		maPartie.setCaseX(parPartie.getCaseX());
		maPartie.setCaseY(parPartie.getCaseY());
		maPartie.setAncienX(parPartie.getAncienX());
		maPartie.setAncienY(parPartie.getAncienY());
		maPartie.setPieceSelectionnee(parPartie.getPieceSelectionnee());
		maPartie.setJoueurBleu(parPartie.getJoueurBleu());
		maPartie.setNbTourDeJeu(parPartie.getNbTourDeJeu());

		// Pour avoir la position de la partie dans l'ArrayList si elle existe déjà, sinon cette méthode retourne -1 si la partie n'a pas été trouvée.
		int position=contientPartie(maPartie.getNom()); 
		
		if( position != -1 ) // Si la partie existe deja
		{
			chListeParties.remove(position);	// On la supprime
			chListeParties.add(position, maPartie);	// Et on la rajoute à nouveau
		}
		else
			chListeParties.add(maPartie); // Sinon on l'ajoute a la fin de l'ArrayList
			
		ecritureFichier();		// On ecrit dans tous les cas dans le fichier
		
	} // fin sauvegarder
		
	private void ecritureFichier()
	{		
		try
		{
			ObjectOutputStream chOutput = new ObjectOutputStream(
											new FileOutputStream(chFichier));
			chOutput.writeObject(this);
			chOutput.flush();
			chOutput.close();
		}
		catch(IOException parException)
		{
			System.err.println("Problème lors de la sauvegarde dans le fichier.");
			System.err.println(parException);
		}
	} // fin ecritureFichier

Toujours dans cette classe, les méthodes qui font la lecture et le chargement :

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
	public DonneesPartie charger(String parNom, boolean premierChargement)
	{
		if(chFichier.exists())
		{
			if(premierChargement)
				lectureFichier();
 
			int position = contientPartie(parNom);
 
			if(position != -1)
				return chListeParties.get(position);
			else
				return null;
		}
		else
			return null;
	} // fin charger
 
	private void lectureFichier()
	{			
		try
		{
			// On instancie un GestionFichier pour tout recuperer
			GestionSauvegarde contenuFichier = new GestionSauvegarde();		
			ObjectInputStream chInput = new ObjectInputStream(
											new FileInputStream(chFichier));
			contenuFichier = (GestionSauvegarde) (chInput.readObject());
			// Recuperation des annees sauvegardees
			chListeParties = contenuFichier.getParties();
		}	
		catch (ClassNotFoundException parException) {
			System.err.println("Problème lors de la lecture du fichier : 01.");
			System.err.println(parException);
		}
		catch (EOFException parException) {
			System.err.println("Problème lors de la lecture du fichier : 02.");
			System.err.println(parException);
		}
		catch (IOException parException) {
			System.err.println("Problème lors de la lecture du fichier : 03.");
			System.err.println(parException);
		}
	} // fin lectureFichier

La classe qui gère les données importante à sauvegarder :

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
import javax.swing.JPanel;
import java.io.*;
 
public class DonneesPartie implements Serializable
{
	// Pour indentifier la partie
	String nomDeLaPartie;
 
	// Les sous-composants de la fenetre
	private JPanel [] [] lesCases;
 
	// Les coordonnes de la case selectionnee
	private int caseX;
	private int caseY;
	private int ancienX;
	private int ancienY;
 
	// Un boolean pour dire si une piece est selectionnee
	private boolean pieceSelectionnee;
 
	// Un tableau pour les positions des pieces
	private Piece [] [] lesPieces;
 
	// On creer un joueur
	private boolean joueurBleu;
 
	private int nbTourDeJeu;
 
	// Pour gérer la partie
	boolean partieEnCours;
	boolean premierChargement;
 
    public DonneesPartie() 
    {
    	lesPieces = new Piece[Plateau.longueur][Plateau.largeur];
    	lesCases = new JPanel[Plateau.longueur][Plateau.largeur];
		for(int i=0 ; i<=Plateau.largeur-1 ; i++)
		{
			for(int j=0 ; j<=Plateau.longueur-1 ; j++)
			{
				lesCases[i][j] = new JPanel();
			}
		}
    }
 
	//----------------------  Les accesseurs pour identifier une partie  ----------------------
	public String getNom()
	{
		return nomDeLaPartie;
	}
 
	public int getNbTourDeJeu()
	{
		return nbTourDeJeu;
	}
 
	public boolean getJoueurBleu()
	{
		return joueurBleu;
	}
 
	public boolean getPieceSelectionnee()
	{
		return pieceSelectionnee;
	}		
 
	public int getAncienY()
	{
		return ancienY;
	}
 
	public int getAncienX()
	{
		return ancienX;
	}
 
	public int getCaseY()
	{
		return caseY;
	}
 
	public int getCaseX()
	{
		return caseX;
	}
 
	public JPanel getCases(int i, int j)
	{
		return lesCases [i][j];
	}
 
	public Piece getPieces(int i, int j)
	{
		return lesPieces [i][j];
	}
	//----------------------  Fin des accesseurs  --------------------
 
	//----------------------  Les modifieurs pour copier une partie  ----------------------
	public void  setNom(String parNom)
	{
		nomDeLaPartie = parNom;
	}
 
	public void setNbTourDeJeu(int parNbTourDeJeu)
	{
		nbTourDeJeu = parNbTourDeJeu;
	}
 
	public void setJoueurBleu(boolean parJoueurBleu)
	{
		joueurBleu = parJoueurBleu;
	}
 
	public void setPieceSelectionnee(boolean parPieceSelectionnee)
	{
		pieceSelectionnee = parPieceSelectionnee;
	}		
 
	public void setAncienY(int parY)
	{
		ancienY = parY;
	}
 
	public void setAncienX(int parX)
	{
		ancienX = parX;
	}
 
	public void setCaseY(int parY)
	{
		caseY = parY;
	}
 
	public void setCaseX(int parX)
	{
		caseX = parX;
	}
 
	public void setCases(JPanel parCase, int i, int j)
	{
		lesCases [i][j] = parCase;
	}
 
	public void setPieces(Piece parPiece, int i, int j)
	{
		lesPieces [i][j] = parPiece;
	}
	//----------------------  Fin des modifieurs  --------------------
}

Le problème est simple :

Quand je récupère les JPanel et les Pieces sauvegardés, je n'ai que des null ou des JPanel "invalid" dans tous les sens.
La solution serait donc de ne pas sauvegarder les JPanel et de recopier chaque champ des objets de la classe Piece...

Peut être qu'il y a d'autre solution ?