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 :
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 :
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 :
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 :
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 ?
Passage par référence ne permet pas la sauvegarde
Répondre avec citation
Partager