[Sérialisation] Problème

Version imprimable

Salut !

J'ai un problème avec la sérialisation; je vous donne le code et vous explique ensuite :

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 class Fichier {
 
    private Placement sudomodele;
    private Jeu jeumodele;       
 
    public Fichier(Placement smodele,Jeu jmodele) {
        this.sudomodele = smodele;
        this.jeumodele = jmodele;
    }
 
    public void ouverturet() throws IOException{
        JFileChooser jfc=new JFileChooser(".");  
        jfc.setMultiSelectionEnabled(false);
        int retour = jfc.showOpenDialog(null);
        if(retour == JFileChooser.APPROVE_OPTION) {
            File inputFile = new File(jfc.getSelectedFile().getName());
            Scanner sc = new Scanner(inputFile).useDelimiter("\n");
            jeumodele.nouveaujeu();
            sudomodele.initialisationGrille(sc);
        }
    }
 
    public void ouverturej() throws IOException{
        jeumodele.nouveaujeu();
        try {
            FileInputStream fichier = new FileInputStream("sudomi.jeu");
            ObjectInputStream ois = new ObjectInputStream(fichier);
            sudomodele = (Placement) ois.readObject();
        } 
        catch (java.io.IOException e) {
            e.printStackTrace();
        }
        catch (ClassNotFoundException e) {
            e.printStackTrace();
        }        
        sudomodele.notifyObservers();        
    }    
 
    public void sauvegarde(){       
        try {
            FileOutputStream fichier = new FileOutputStream("sudomi.jeu");
            ObjectOutputStream oos = new ObjectOutputStream(fichier);
            oos.writeObject(sudomodele);
            oos.flush();
            oos.close();
        }
        catch (java.io.IOException e) {
            e.printStackTrace();
        }       
    }
}

Et pour info :

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
 
public abstract class Sudoku {
 
    protected Macase[][] grillep= new Macase [9][9];    
    protected int chiffrechoisi=0;
    protected boolean [] tabmessage = new boolean [4];
    protected boolean jeudemarre;
    protected boolean nouveaujeu;
 
    public Sudoku(){
        for(int i=0;i<9;i++){
            for(int j=0;j<9;j++){
                this.grillep[i][j]=new Macase();
            }
        }
        for (int i=0;i<tabmessage.length;i++) {
            tabmessage[i]=false;
        }
        this.jeudemarre=false;
    }
 
...
 
}

Code:

1
2
3
4
5
6
7
8
 
public class Placement extends Sudoku implements java.io.Serializable{
 
    private static final long serialVersionUID = 3032191156608661892L;
 
...
 
}

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
 
public class Pgrmsudoku extends JFrame{
 
    private static final long serialVersionUID = 6787164115803472272L;
 
    Placement sudoku = new Placement();    
    Jeu jeu = new Jeu(sudoku);
    PanelVue1 pVue1 = new PanelVue1(sudoku);
    PanelVue2 pVue2 = new PanelVue2(sudoku,jeu);
    Fichier fichier = new Fichier(sudoku,jeu);    
    Menu menuBar = new Menu(sudoku,fichier,jeu);
 
    public static void main(String args[]) {
 
        try {
            UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
        }
        catch (Exception e) {
            e.printStackTrace();
        }        
        Pgrmsudoku f = new Pgrmsudoku();    
        f.setPreferredSize(new Dimension(900,700));
        f.setResizable(false);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);        
        f.pack();
        f.setVisible(true);
    }
 
    public Pgrmsudoku(){
 
        this.setTitle("Jeu du Sudoku");
        this.getContentPane().add(pVue1, BorderLayout.EAST);
        this.getContentPane().add(pVue2, BorderLayout.WEST);        
        this.setJMenuBar(menuBar);
    }    
}

Voilà ! Je ne vous donne pas les autres classes, c'est sans intéret ...

En fait, ce sont les méthodes ouverturej et sauvegarde de la classe Fichier qui me causent problème. Le programme tourne bien... mais après une ouverture, je ne retrouve rien de ce qui est censé avoir été enregistré dans le fichier...

Où est-ce que je me suis fourvoyé ?...
Merci d'avance !

22/05/2006, 16h33
le y@m's

Ta classe Placement hérite de ta classe Sudoku qui n'est pas sérialisable, du coup il me semble que tous les membres hérités de la classe Sudoku ne seront pas sérialisés. Essaye en faisant implémenter l'interface Serializable par ta classe Sudoku.
22/05/2006, 17h18
Mike888

Ben en fait, pas encore car j'ai toujours un petit souci ...

Bon, maintenant, readObject renvoie tout ce qu'il faut !! Ca, ça roule correctement !

Mais le problème, c'est que mon notifyObservers devrait mettre ton le prog à jour; or il n'en est rien ... Je suspecte un mauvais emploi de la variable sudomodele ...
22/05/2006, 17h27
le y@m's

Je ne sais pas ce que fait la methode notifyObservers (peut-tu nous montrer un peu de code), mais en ce qui concerne l'attribut sudomodele sache qu'à la ligne

Code:

sudomodele = (Placement) ois.readObject();

tu écrase l'instance précedemment stockée (et donc tous les liens éventuels vers d'autres objets).
22/05/2006, 17h34
Mike888
Citation:

Envoyé par le y@m's

Je ne sais pas ce que fait la methode notifyObservers (peut-tu nous montrer un peu de code), mais en ce qui concerne l'attribut sudomodele sache qu'à la ligne

Code:

sudomodele = (Placement) ois.readObject();

tu écrase l'instance précedemment stockée (et donc tous les liens éventuels vers d'autres objets).

Ben, c'est le but de l'écraser ... Enfin, je suppose :oops:.
Sudomodele est la variable qui "contient" l'ensemble des variables de classes de mon programme. Il est donc normal que je l'écrase quand je veux la mettre à jour avec le readObject, non ?...

Pour le notifyObserver, ben il met à jour tout le GUI (grille de sudoku), grace aux updateObservers :
Code:

1 2 3 4 5 6 7 public void notifyObservers() { Iterator<Observer> iterator = observers.iterator(); while (iterator.hasNext()) { iterator.next().updateObserver(); } }
22/05/2006, 17h44
le y@m's

Citation:

Envoyé par Mike888

Ben, c'est le but de l'écraser ... Enfin, je suppose :oops:.
Sudomodele est la variable qui "contient" l'ensemble des variables de classes de mon programme. Il est donc normal que je l'écrase quand je veux la mettre à jour avec le readObject, non ?...

Oui c'est normal :mrgreen: , je voulais juste insisté sur le fait que les liens avec les autres objets (notamment les observers) n'étés plus valable.
Tu appel la méthode notifyObservers sur le "nouveau" sudomodele or celui-ci ne connait pas les autres objets (je veus dire par là qu'il n'a aucun lien vers les instances des autres objets).
22/05/2006, 18h10
Mike888

A mon avis, y'a un concept sur la serialisation qui m'a échappé ...

Mais dans mon cas, ca signifie quoi exactement ? Que je dois réinstancier toutes les variables; ou bien recréer de liens ... ?
22/05/2006, 18h26
le y@m's
Citation:

Envoyé par Mike888

Mais dans mon cas, ca signifie quoi exactement ? Que je dois réinstancier tous les variables ?...

Non pas du tout.
une fois que tu as récupéré ton sudomodele tu appel la methode notifyObservers, or celle-ci appelle la methode updateObserver de chaque Observer d'une Collection
Code:

1 2 3 4 5 6 7 public void notifyObservers() { Iterator<Observer> iterator = observers.iterator(); while (iterator.hasNext()) { iterator.next().updateObserver(); } }
Mais elle sort d'où cette Collection observers ?

D'ici -->

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public abstract class Sudoku implements java.io.Serializable{
 
...    
 
    private HashSet<Observer> observers = new HashSet<Observer>();
 
    public void addObserver(Observer observer) {
        observers.add(observer);
    }
 
    public void notifyObservers() {
        Iterator<Observer> iterator = observers.iterator();
        while (iterator.hasNext()) {
            iterator.next().updateObserver();
        }
    }
 
...
 
}

22/05/2006, 18h37
le y@m's

Tes Observers font donc partie de sudomodele. Alors plusieurs remarques
1°) Est-ce que tes Observers sont sérialisable ? As-tu vérifier que ton HashSet contient bien les Observers que tu avais lors de la sauvegarde ?
2°) Je suppose que Tes Observers doivent êtres "liés" à l'interface graphique pour pouvoir la mettre à jour. Donc comment tu "lie" les Observers du sudomodele aux instances des composants graphiques de ton IHM ?

Citation:

Envoyé par le y@m's

Tes Observers font donc partie de sudomodele. Alors plusieurs remarques :

1°) Est-ce que tes Observers sont sérialisables ?

Ca, c'est une bonne question ! Je n'en ai aucune idée, je peux savoir ça comment ?

Citation:

Envoyé par le y@m's

2°) As-tu vérifié que ton HashSet contient bien les Observers que tu avais lors de la sauvegarde ?

Tu veux dire lorsque je fais une ouverture ?...

- Quoiqu'il en soit, lorsque j'inscris un chiffre dans une case (et que donc je fais un appel l'updateObserver d'une mes classes du GUI grace au notifyObserver), voilà ce que j'obtiens, avec un toString de l'observer (par ex pour le chiffre 6) :

java.util.HashMap$KeyIterator@c3c315
java.util.HashMap$KeyIterator@c3c315

NB: J'ai deux observers (d'où les 2 lignes)

- Si maintenant, je demande qu'il m'affiche le toString après l'ouverture :

java.util.HashMap$KeyIterator@1e9d9b1
java.util.HashMap$KeyIterator@1e9d9b1
java.util.HashMap$KeyIterator@19845fb
java.util.HashMap$KeyIterator@19845fb

NB: 2*2 ; il y a eu une duplication :? (dois-je en déduire que les observers n'ont pas été sérialisés ?...)

Citation:

Envoyé par le y@m's

3°) Je suppose que Tes Observers doivent êtres "liés" à l'interface graphique pour pouvoir la mettre à jour.

Ah ben oui !!

Citation:

Envoyé par le y@m's

4°) Donc comment tu "lies" les Observers du sudomodele aux instances des composants graphiques de ton IHM ?

Ben dans ma classe en question, je fais un :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public class PanelVue1 extends JPanel implements Observer{ private static final long serialVersionUID = -6098308324626190230L; private Placement sudomodele; ... public PanelVue1(Placement smodele){ this.sudomodele = smodele; smodele.addObserver(this); ... } }
En tous cas, merci de m'aider !! ;)

22/05/2006, 19h35
le y@m's

Ok je crois que je vois ce qui ne va pas.
Quand tu charge le sudomodele (désérialisation) et que tu appel la methode notifyObserver, celle-ci mets à jour les Observers (les PanelVue1 si j'ai bien compris) contenus dans le HashSet du sudomodele.
Le problème est que ceux-ci sont différent de ceux qui sont affichés (pas la même instance). Les PanelVue1 que tu vois sur l'interface graphique sont toujours ceux de l'ancien sudomodele.
Il faut que tu remplace les ancien PanelVue1 par les nouveau (dans ta JFrame ou autre conteneur).
22/05/2006, 19h42
Mike888

Ah, je vais essayer ça ;)

NB: j'ai déclaré le HashSet en protected, ça corrige déjà la duplication ...
22/05/2006, 20h00
Mike888

En fait, y'a qqch qui m'echappe dans ton explication :

Citation:

Quand tu charge le sudomodele (désérialisation) et que tu appel la methode notifyObserver, celle-ci mets à jour les Observers (les PanelVue1 si j'ai bien compris) contenus dans le HashSet du sudomodele.

Là, je suis Ok !

Citation:

Le problème est que ceux-ci sont différent de ceux qui sont affichés (pas la même instance). Les PanelVue1 que tu vois sur l'interface graphique sont toujours ceux de l'ancien sudomodele.

Par contre, là, je suis moins d'accord; les PanelVue réagissent en fonction des valeurs des variables des classes du package modèle. Donc, ils devraient etre instantanément mis à jour dès lors que je fais un notify...
Pourquoi recréer une nouvelle instance de chaque PanelVue ???
22/05/2006, 20h18
le y@m's

Quand tu sérialise ton sudomodele, tu sérialise tous ses attributs y compris le HashSet et donc les PanelVue. Quand tu désérialise, en fait, de nouvelles instances sont créées en fonctions des données désérialisés.
Quand tu sérialise, tu sauvegarde la valeur des objets (et pas l'instance). Pour schématiser, le processus de désérialisation consiste à créer une nouvelle instance d'un objet qui aura la même valeur que celle sauvegardée.
Donc ton sudomodele est lié aux nouvelles instances des PanelVue désérialisés et non à celles qui sont dans ton IHM.
22/05/2006, 20h36
Mike888

Aaaah Okay !!!
Merci pour cette claire explication (je vois donc ce qui m'echappait dans la sérialisation ...).

Bon, maintenant, je vais tester tout ça !!
22/05/2006, 21h00
Mike888

C'est bete mais je vois pas trop comment je peux aller remplacer l'ancien panelVue par le nouveau dans ma classe principale ...
Peut-être que je me suis trompé dans la conception et que je n'aurais pas du les déclarer là ...
22/05/2006, 21h49
le y@m's
Je pense effectivement que sérialiser les panels n'est pas la bonne solutions.
normalement une application se divise en 3 parties :
- Données (stockage et récupération des données)
- Métier (traitement des données)
- Interface utilisateur (affichage et saisie des données)
et s'agance comme ça :
Données <-> Métier <-> Interface utilisateur

Bien que ce soit moins important pour des petites applications (plus une application est petite, plus ces parties on tendance à se rapprocher voir fusionner), il vaut mieux garder ce schéma à l'esprit.

Voilà, reprend un peu la conception de ton application et n'hésite pas si tu as des questions.

Bon courage ;)
22/05/2006, 22h01
Mike888

Ben ecoute, le schema que tu as donné s'applique très bien dans le case de DB par ex...
Mais ici, c'est plus du MVC (dont j'ai d'ailleurs oté le controleur, comme c'est apparement dans l'air du temps); et je me suis basé sur l'organisation des classes que notre prof emploie et préconise...
Donc, pour moi, l' "architecture" est correcte ...

Je continue à chercher :roll:
23/05/2006, 00h11
le y@m's

La partie donnée n'est pas forcement relié à une BD, il peut aussi s'agir de fichiers plats, (fichiers properties, fichiers xml ou sérialisation dans ton cas).
Dans ton cas le problème est que tu "mélange" stockage des données et IHM.
Je suis d'accord sur le fait de ne pas forcement utiliser le schema 3 tiers à la lettre, mais même si les frontières peuvent être floues, je pense qu'il faut en tenir compte un minimum (la preuve, tu as vu les problèmes soulevés dans ton cas ;)).
De plus l'architecture 3 tiers n'est pas du tout antinomique avec le pattern MVC.
23/05/2006, 00h19
Mike888

Pourtant, je t'assure que c'est ainsi que notre prof travaille (et c'est loin d'etre une brele en programmation ...)
23/05/2006, 02h44
le y@m's

Je ne remets pas en cause la façon de travailler de ton prof :D (surtout que je ne la connais pas), je ne fait que te partager ma petite expérience.
En tout état de cause, il n'y a pas une seule façon de programmer et de concevoir une application. Il y a juste certaines approches à connaitre, après c'est à toi d'analyser le problème et d'essayer de trouver la façon la plus judicieuse de developper ton application ;).

Serait-il envisageable de faire qqch de la sorte ...

Ma classe Pgrmudoku :

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
 
public class Pgrmsudoku extends JFrame{
 
    private static final long serialVersionUID = 6787164115803472272L;
 
    Placement sudoku = new Placement();
    Jeu jeu = new Jeu(sudoku);
    PanelVue1 pVue1 = new PanelVue1(sudoku);
    PanelVue2 pVue2 = new PanelVue2(sudoku,jeu);
    Fichier fichier = new Fichier(this,sudoku,jeu);
    Menu menuBar = new Menu(sudoku,fichier,jeu);
 
    public Pgrmsudoku(){
 
        this.setTitle("Jeu du Sudoku");
        this.getContentPane().add(pVue1, BorderLayout.EAST);
        this.getContentPane().add(pVue2, BorderLayout.WEST);
        this.setJMenuBar(menuBar);
        init();
    }
 
    public void init(){
        try {
            UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
        }
        catch (Exception e) {
            e.printStackTrace();
        }    
        this.setPreferredSize(new Dimension(900,700));
        this.setResizable(false);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.pack();
        this.setVisible(true);
    }
 
    public void reloadGUI(){
        this.getContentPane().remove(pVue1);
        this.getContentPane().remove(pVue2);    
        pVue1=null;
        pVue2=null;    
        PanelVue1 pVue1 = new PanelVue1(sudoku);
        PanelVue2 pVue2 = new PanelVue2(sudoku,jeu);    
        this.getContentPane().add(pVue1, BorderLayout.EAST);
        this.getContentPane().add(pVue2, BorderLayout.WEST);
        init();
    }
}

Et d'appeller la méthode reloadGUI depuis la classe Fichier (méthode ouverturej) ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
public void ouverturej() throws IOException{
        try {
            FileInputStream fichier = new FileInputStream("sudomi.jeu");
            ObjectInputStream ois = new ObjectInputStream(fichier);
            sudomodele = (Placement) ois.readObject();
        } 
        catch (java.io.IOException e) {
            e.printStackTrace();
        }
        catch (ClassNotFoundException e) {
            e.printStackTrace();
        }        
        pgrm.reloadGUI();
        sudomodele.notifyObservers();            
    }

Attention, je dis peut-être nawak ... N'hésite pas à me lyncher si nécessaire ... :mrgreen:

23/05/2006, 17h14
le y@m's

Le problème reste le même. Tu appel la methode reloadGUI() qui remplace les PanelVue par de "nouveau", cependant, ceux-ci n'ont toujours rien à voir avec ceux du sudomodele que tu as déssérialisé.
Le sudomodele que tu charge n'a toujours aucun lien avec ton IHM.
Peut-être que ta methode reloadGUI devrait prendre en paramètre un Placement, ainsi dans ouverturej tu appel

Code:

reloadGUI(sudomodele);

Ou un truc dans le genre.
23/05/2006, 17h32
Mike888

Bon sang, mais c'est bien sur !!! Tu as absolument raison; dans ma méthode reloadGUI, je passais l'ancien sudoku au constructeur des PanelVues et non le nouveau ! (moi et la distraction ca fait 2 :roll: )...

Je te fais un virement sur ton compte ? :lol:

Sinon, question design, elle fait pas un peu tache cette méthode reloadGUI (je veux dire un peu bourrin) ?
En fait, cette classe Pgrmsudoku aurait plus sa place dans un package constructeur, non ?
23/05/2006, 18h05
le y@m's

Citation:

Envoyé par Mike888

Sinon, question design, elle fait pas un peu tache cette méthode reloadGUI (je veux dire un peu bourrin) ?

Non.

Citation:

Envoyé par Mike888

En fait, cette classe Pgrmsudoku aurait plus sa place dans un package constructeur, non ?

J'ai pas compris ce que tu voulais dire.

Citation:

Envoyé par Mike888

Je te fais un virement sur ton compte ? :lol:

T'inquiete, je t'envoie la facture et le numero de compte :mouarf: :aie:
23/05/2006, 18h09
Mike888

Dernière question, et après je passe en [résolu] :

Tu as dit que lors de la désérialisation, une nouvelle instance était créée pour tous les objets sérialisés (qui ont la meme valeur)... Ca veut dire qu'en fait, je me retrouve avec un duplicata de chaque objet (une double instanciation), ou alors la nouvelle instance écrase l'ancienne ?

Le mieux c'est un exemple.
Soit la classe Personne suivante :
Code:

1 2 3 4 5 6 7 8 9 10 11 public class Personne implements Serializable { static final long serialVersionUID = 10L; private String nom; private Integer age; public Personne(String nom, Integer age) { this.nom = nom; this.age = age; } }
maintenant le code suivant (avec la méthode savePersonne() qui s'occupe de la sérialisation):
Code:

1 2 3 4 5 String nom = "Dupont"; Integer age = 51; Personne p = new Personne(nom, age); savePersonne(p); // on sérialise la personne.
maintenant le code suivant (avec la méthode loadPersonne() qui s'occupe de la déssérialisation):
Code:

1 2 3 4 5 6 String vNom = "Durand"; Integer vAge = 48; Personne p = new Personne(nom, age); Personne p2 = p; p = loadPersonne(); // on déssérialise la personne.
ici la variable p à été écrasée (le nom et l'age sont "Dupont" et 51) néanmoins l'instance précédente n'a pas été détruite pour autant puisqu'elle est toujours référencée par p2 (le nom et l'age sont "Durand" et 48), de même la variable "vAge" vaut toujours 48 et la variable "vNom" vaut toujours "Durand".

23/05/2006, 18h50
Mike888

Oui, donc en résumé, il y a écrasement (je parle dans mon cas) !

Ok ok !
Ben écoute, je ne vois plus rien d'autre pour le moment... Mais je suis sur que d'autres questions surgiront à un moment ou un autre !

En tous cas, un énorme merci pour tes explications et ta patience !!! :hola: :D

Dis, je suis pas loin d'avoir résolu mais il me manque une petite étincelle !

Je résume :

1) J'ai un package " Principal " -> 2 classes :

Application
Pgrmsudoku

2) J'ai un package " modele " -> 6 classes :

Fichier
Jeu
Macase
Observer
Placement
Sudoku

3) J'ai un package " vues " -> 4 classes :

Menu
PanelVue1
PanelVue2
Timecounter

Classe Pgrmsudoku :

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
 
public class Pgrmsudoku extends JFrame{
 
    private static final long serialVersionUID = 6787164115803472272L;
 
    Placement sudoku = new Placement();
    Jeu jeu = new Jeu(sudoku);
    Fichier fichier = new Fichier(this,sudoku,jeu);
    Menu menuBar = new Menu(sudoku,fichier,jeu);
    PanelVue1 pVue1 = new PanelVue1(sudoku);
    PanelVue2 pVue2 = new PanelVue2(sudoku,jeu);
 
    public Pgrmsudoku(){
 
        this.setTitle("Jeu du Sudoku");
        this.getContentPane().add(pVue1, BorderLayout.EAST);
        this.getContentPane().add(pVue2, BorderLayout.WEST);
        this.setJMenuBar(menuBar);
        init();
    }
 
    public void init(){
        try {
            UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
        }
        catch (Exception e) {
            e.printStackTrace();
        }    
        this.setPreferredSize(new Dimension(900,700));
        this.setResizable(false);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.pack();
        this.setVisible(true);
    }
 
    public void reloadGUI(Placement sudomodele){
        this.getContentPane().remove(pVue1);
        this.getContentPane().remove(pVue2);
        pVue1 = null;
        pVue2 = null;
        pVue1 = new PanelVue1(sudomodele);
        pVue2 = new PanelVue2(sudomodele,jeu);
        this.getContentPane().add(pVue1, BorderLayout.EAST);
        this.getContentPane().add(pVue2, BorderLayout.WEST);
        init();        
    }
}

Classe Sudoku :

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
 
public abstract class Sudoku implements java.io.Serializable{
 
    protected Macase[][] grillep= new Macase [9][9];    
    protected int chiffrechoisi=0;
    protected boolean [] tabmessage = new boolean [4];
    protected boolean jeudemarre;
    protected boolean nouveaujeu;
    protected HashSet<Observer> observers = new HashSet<Observer>();
 
    public Sudoku(){
        for(int i=0;i<9;i++){
            for(int j=0;j<9;j++){
                this.grillep[i][j]=new Macase();
            }
        }
        for (int i=0;i<tabmessage.length;i++) {
            tabmessage[i]=false;
        }
        this.jeudemarre=false;
        this.nouveaujeu=false;
    }
 
    public void addObserver(Observer observer) {
        observers.add(observer);
    }
 
    public void notifyObservers() {
        Iterator<Observer> iterator = observers.iterator();
        while (iterator.hasNext()) {
            iterator.next().updateObserver();
        }        
    }
...
}

Classe 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
53
54
55
 
public class Fichier {
 
    private Placement sudomodele;
    private Jeu jeumodele;
    private Pgrmsudoku pgrm;
 
    public Fichier(Pgrmsudoku pgrm,Placement smodele,Jeu jmodele) {
        this.sudomodele = smodele;
        this.jeumodele = jmodele;
        this.pgrm=pgrm;
    }
 
    public void ouverturet() throws IOException{
        JFileChooser jfc=new JFileChooser(".");    
        jfc.setMultiSelectionEnabled(false);
        int retour = jfc.showOpenDialog(null);
        if(retour == JFileChooser.APPROVE_OPTION) {
            File inputFile = new File(jfc.getSelectedFile().getName());           
            Scanner sc = new Scanner(inputFile).useDelimiter("\n");    
            jeumodele.nouveaujeu();
            sudomodele.initialisationGrille(sc);            
        }
    }
 
    public void ouverturej() throws IOException{
        try {
            FileInputStream fichier = new FileInputStream("sudomi.jeu");
            ObjectInputStream ois = new ObjectInputStream(fichier);
            sudomodele = (Placement) ois.readObject();
        } 
        catch (java.io.IOException e) {
            e.printStackTrace();
        }
        catch (ClassNotFoundException e) {
            e.printStackTrace();
        }        
        sudomodele.observers.removeAll(sudomodele.observers);    
        pgrm.reloadGUI(sudomodele);        
        sudomodele.notifyObservers();    
    }
 
    public void sauvegarde(){      
        try {
            FileOutputStream fichier = new FileOutputStream("sudomi.jeu");
            ObjectOutputStream oos = new ObjectOutputStream(fichier);
            oos.writeObject(sudomodele);
            oos.flush();
            oos.close();
        }
        catch (java.io.IOException e) {
            e.printStackTrace();
        }            
    }
}

Classe Jeu :

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
 
public class Jeu implements java.io.Serializable {
 
    private static final long serialVersionUID = 4713733833983112912L;
 
    private Placement sudomodele;    
 
    public Jeu(Placement smodele){
        this.sudomodele=smodele;        
    }
 
    public void nouveaujeu(){
        int i,j,k;
        boolean []tabp;
        boolean []tabm;      
 
        for (i=0;i<9;i++){
            for (j=0;j<9;j++){
                sudomodele.getGrillep()[i][j].setValeur(0);
                sudomodele.getGrillep()[i][j].setVerrou(false);
                sudomodele.getGrillep()[i][j].setEtatpile(false);
                tabp=sudomodele.getGrillep()[i][j].getPossibilite();
                for (k=0;k<9;k++) tabp[k]=false;
                sudomodele.getGrillep()[i][j].setPossibilite(tabp);
            }
        }
        sudomodele.setChiffrechoisi(0);
        tabm=sudomodele.getTabmessage();
        for (k=0;k<4;k++){
            tabm[k]=false;                    
        }
        sudomodele.setTabmessage(tabm);
        sudomodele.setNouveaujeu(true);
        sudomodele.notifyObservers();        
    }
 
    public void demarreJeu(){
        int i,j,k;
        boolean []tab;        
        for (i=0;i<9;i++) {
            for (j=0;j<9;j++) {
                if (sudomodele.grillep[i][j].isVerrou()==false && sudomodele.grillep[i][j].getValeur()!=0) {
                    sudomodele.grillep[i][j].setVerrou(true);                                    
                }                
                tab=sudomodele.getGrillep()[i][j].getPossibilite();
                for (k=0;k<9;k++) tab[k]=false;
                sudomodele.grillep[i][j].setPossibilite(tab);
                sudomodele.grillep[i][j].setEtatpile(false);
            }
        }        
        sudomodele.setJeudemarre(true);
        sudomodele.notifyObservers();        
    }
}

Le seul problème qu'il reste, c'est avec les méthodes de la classe jeu; elles restent sans effet. Elle s'exécutent, ça j'en suis sur, mais c'est tout ! Par contre, si je déplace une des méthodes (copier-coller) vers la classe fichier et que je l'exécute, là, ça prend !!! Donc, on dirait qu'il y a un problème d'instance avec la classe jeu ... mais où ?

24/05/2006, 01h17
le y@m's

Il y a un truc qui me "choque", ta classe Pgrmsudoku possède un attribut Placement et un attribut Jeu or la classe Jeu possède elle aussi un attribut de type Placement. Je pense que c'est une erreur de conception et c'est à mon avis celle-ci qui est à l'origine de ton problème.
En effet quand tu charge ton Placement, l'attribut Jeu de ton Pgrmsudoku lui reste le même.

A mon avis, tu devrais enlever l'attribut Placement de ta classe Pgrmsudoku et rajouter des accesseurs/modifieurs dans ta classe Jeu pour acceder à son attribut Placement et travailler avec depuis ta classe Pgrmsudoku.
24/05/2006, 01h52
Mike888
Euh, j'ai eu un peu de mal à suivre ton raisonnement :?
Code:

1 2 3 4 5 public class Pgrmsudoku extends JFrame{ Placement sudoku = new Placement(); ... }
Mais si je delete l'attribut Placement de ma classe Pgrmsudoku, qu'est-ce que je vais passer aux constructeurs des classes auxquelles je passais "sudoku" ?
Dois-je appliquer ce que tu as dit à toutes mes classes ?... Ca me parait bizarre !

Et puis le phénomène serait identique avec la classe Fichier; or ce n'est pas le cas ...

Citation:

ta classe Pgrmsudoku possède un attribut Placement et un attribut Jeu or la classe Jeu possède elle aussi un attribut de type Placement.

Effectivement, mais j'instancie sudomodele avec le paramètre passé au constructeur, à savoir le fameux sudoku de ma classe Pgrmsudoku... Donc, c'est bien résultat escompté !

A mon avis, c'est une betise bcp plus simple ...

Citation:

Envoyé par Mike888

Mais si je delete l'attribut Placement de ma classe Pgrmsudoku, qu'est-ce que je vais passer aux constructeurs des classes auxquelles je passais "sudoku" ?

Tu utilise celui de la classe Jeu (il est vrai que tu peus faire la même chose pour ta classe Fichier).

En fait tu as plein d'attributs redondants, donc il faut à chaque fois tous les modifier ce qui n'est pas très pratique (et qui amène les problèmes qui se posent à toi).
Ta structure ressemble a ça :

Code:

1
2
3
4
5
6
 
Pgrmsudoku  -> Jeu
           |-> Placement
           |-> Fichier -> Pgrmsudoku 
                      |-> Jeu -> Placement
                      |-> Placement

Tu vois bien qu'il y a un truc qui ne va pas (notamment avec la classe Placement).

Il faut restructurer l'organisation de tes classes pour avoir un truc du genre :

Code:

1
2
3
 
Pgrmsudoku  -> Jeu -> Placement
           |-> Fichier -> Pgrmsudoku

en gros cela donnerai :

Classe Pgrmsudoku : suppression de l'attribut de type Placement, rajout des getters/setters pour l'attribut de type Jeu, adaptation de la méthode reloadGUI()

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
 
public class Pgrmsudoku extends JFrame{
 
    private static final long serialVersionUID = 6787164115803472272L;
 
    Jeu jeu;
    Fichier fichier;
    Menu menuBar;
    PanelVue1 pVue1;
    PanelVue2 pVue2;
 
    public Pgrmsudoku(){
 
        jeu = new Jeu(new Placement());
        fichier = new Fichier(this);
        menuBar = new Menu(jeu.getSodumodele() ,fichier,jeu);
        pVue1 = new PanelVue1(jeu.getSodumodele());
        pVue2 = new PanelVue2(jeu.getSodumodele(),jeu);
 
        this.setTitle("Jeu du Sudoku");
        this.getContentPane().add(pVue1, BorderLayout.EAST);
        this.getContentPane().add(pVue2, BorderLayout.WEST);
        this.setJMenuBar(menuBar);
        init();
    }
 
    public void init(){
        try {
            UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
        }
        catch (Exception e) {
            e.printStackTrace();
        }    
        this.setPreferredSize(new Dimension(900,700));
        this.setResizable(false);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.pack();
        this.setVisible(true);
    }
    public Jeu getJeu() {
        return jeu;
    }
    public void setJeu(Jeu jeu) {        
        this.jeu = jeu;
        reloadGUI();
    }
    public void reloadGUI() {
        this.getContentPane().remove(pVue1);
        this.getContentPane().remove(pVue2);
        pVue1 = null;
        pVue2 = null;
        pVue1 = new PanelVue1(jeu.getSudomodele());
        pVue2 = new PanelVue2(jeu.getSudomodele(), jeu);
        this.getContentPane().add(pVue1, BorderLayout.EAST);
        this.getContentPane().add(pVue2, BorderLayout.WEST);
        init();       
    }
}

Classe Jeu : ajout des getters/setters pour l'attribut de type Placement

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
public class Jeu implements java.io.Serializable {
 
    private static final long serialVersionUID = 4713733833983112912L;
 
    private Placement sudomodele;    
 
    public Jeu(Placement smodele){
        this.sudomodele=smodele;        
    }
 
    public void nouveaujeu(){
        int i,j,k;
        boolean []tabp;
        boolean []tabm;      
 
        for (i=0;i<9;i++){
            for (j=0;j<9;j++){
                sudomodele.getGrillep()[j].setValeur(0);
                sudomodele.getGrillep()[j].setVerrou(false);
                sudomodele.getGrillep()[j].setEtatpile(false);
                tabp=sudomodele.getGrillep()[j].getPossibilite();
           for (k=0;k<9;k++) tabp[k]=false;
                sudomodele.getGrillep()[j].setPossibilite(tabp);
       }
   }
   sudomodele.setChiffrechoisi(0);
   tabm=sudomodele.getTabmessage();
   for (k=0;k<4;k++){
       tabm[k]=false;                    
   }
   sudomodele.setTabmessage(tabm);
   sudomodele.setNouveaujeu(true);
   sudomodele.notifyObservers();        
}
 
public void demarreJeu(){
   int i,j,k;
   boolean []tab;        
   for (i=0;i<9;i++) {
       for (j=0;j<9;j++) {
                if (sudomodele.grillep[i][j].isVerrou()==false && sudomodele.grillep[j].getValeur()!=0) {
                    sudomodele.grillep[j].setVerrou(true);                                    
           }                
                tab=sudomodele.getGrillep()[j].getPossibilite();
           for (k=0;k<9;k++) tab[k]=false;
                sudomodele.grillep[j].setPossibilite(tab);
                sudomodele.grillep[j].setEtatpile(false);
       }
   }        
   sudomodele.setJeudemarre(true);
   sudomodele.notifyObservers();        
}
 
public Placement getSudomodele() {
      return this.sudomodele();
}
public void setSudomodele(Placement placement) {
      this.sudomodele = placement;
}
}

Classe Fichier : suppression des l'attributs de type Placement et de type Jeu. adaptation du code

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
public class Fichier {
 
    private Pgrmsudoku pgrm;
 
    public Fichier(Pgrmsudoku pgrm) {
        this.pgrm=pgrm;
    }
 
    public void ouverturet() throws IOException{
        JFileChooser jfc=new JFileChooser(".");    
        jfc.setMultiSelectionEnabled(false);
        int retour = jfc.showOpenDialog(null);
        if(retour == JFileChooser.APPROVE_OPTION) {
            File inputFile = new File(jfc.getSelectedFile().getName());           
            Scanner sc = new Scanner(inputFile).useDelimiter("\n");   
            pgrm.getJeu().nouveaujeu();
            pgrm.getJeu().getSudomodele().initialisationGrille(sc);
        }
    }
 
    public void ouverturej() throws IOException{
        Jeu jeu = null;
        try {
            FileInputStream fichier = new FileInputStream("sudomi.jeu");
            ObjectInputStream ois = new ObjectInputStream(fichier);
            jeu = new Jeu((Placement) ois.readObject());
        } 
        catch (java.io.IOException e) {
            e.printStackTrace();
        }
        catch (ClassNotFoundException e) {
            e.printStackTrace();
        }                
        if(jeu != null) {
             pgrm.setJeu(jeu);    
             pgrm.getJeu().getSudomodele().observers.removeAll(sudomodele.observers);   
             pgrm.getJeu().getSudomodele().notifyObservers();    
        }
    }
 
    public void sauvegarde(){      
        try {
            FileOutputStream fichier = new FileOutputStream("sudomi.jeu");
            ObjectOutputStream oos = new ObjectOutputStream(fichier);
            oos.writeObject(pgrm.getJeu().getSudomodele());
            oos.flush();
            oos.close();
        }
        catch (java.io.IOException e) {
            e.printStackTrace();
        }            
    }
}

Il y a de grandes chances que ce code ne marche pas car il y a surement d'autres choses à adapter mais c'est surtout pour te montrer le principe.

24/05/2006, 12h12
Mike888

Hé ben écoute, pour etre sincère, je ne comprends plus rien !
J'ai imprimé le diagramme des classes grâce au plug-in UML d'Eclipse et c'est un vrai foutoir ...

Je comprends plus ou moins ce que tu essaies de me dire. Mais je ne saisis pas bien pourquoi tu veux rendre la classe Jeu pièce maitresse de mon appli...
Et puis tu dis que tu supprimes l'attribut Placement de la classe Pgrmsudoku; mais tu l'y laisses quand meme ... Moi devenir 8O

Pour moi, la pièce centrale de l'application, c'est la classe abstraite Sudoku (dont hérite la classe Placement). Et c'est donc l'instance de cette classe-là (Placement) qui doit etre propagée dans tout le code.

Mais je suis bien conscient qu'il y a un gros bleme au niveau de la conception générale. Comme ils sont très intelligents chez nous, ils donnent UML en 3 ème, mais les projets en 2nde ... (et comme en plus, moi et l'objet, on s'entend pas très fort)...

Enfin, j'y retourne !
24/05/2006, 12h39
le y@m's

Citation:

Envoyé par Mike888

Et puis tu dis que tu supprimes l'attribut Placement de la classe Pgrmsudoku; mais tu l'y laisses quand meme ...

:oops: Désolé, comme j'avais modifié pas mal de chose j'en ai oublié (j'ai corrigé le post).

Citation:

Envoyé par Mike888

Pour moi, la pièce centrale de l'application, c'est la classe abstraite Sudoku (dont hérite la classe Placement). Et c'est donc l'instance de cette classe-là (Placement) qui doit etre propagée dans tout le code.

Ce n'est pas parce qu'une classe est importante qu'il faut que tu la mette en attribut à toutes les autres classes. Mon code ne représente peut-être (sûrement) pas la solution, mais c'était surtout pour te montrer ton erreur de conception et comment tu peus faire pour utiliser ta classe Placement sans la mettre en attribut de partout (ce qui peut être, et a été dans ton cas, la source de nombreux problèmes).

Pour t'aider dans la conception, il y a un forum Modélisation, Méthodes, Architectures, Tests... où tu trouveras surement de l'aide ;) .

Citation:

Envoyé par Mike888

et comme en plus, moi et l'objet, on s'entend pas très fort

et bien tu y est en plein dedans :mouarf:

Eh bien voilà, avec ta méthode, ça a l'air de tourner pile-poil !!
J'ai juste modifié la méthode ouverturej...

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
 
public class Fichier implements java.io.Serializable{
 
    private static final long serialVersionUID = 2331672085839451975L;
 
    private Pgrmsudoku pgrm;
 
    public Fichier(Pgrmsudoku pgrm) {
        this.pgrm=pgrm;
    }
 
    public void ouverturet() throws IOException{
        JFileChooser jfc=new JFileChooser(".");    
        jfc.setMultiSelectionEnabled(false);
        int retour = jfc.showOpenDialog(null);
        if(retour == JFileChooser.APPROVE_OPTION) {
            File inputFile = new File(jfc.getSelectedFile().getName());
 
            /* FileReader in = new FileReader(inputFile);
             int c;
             while ((c = in.read()) != -1) System.out.print((char) c + " ");
             in.close();    */
 
            Scanner sc = new Scanner(inputFile).useDelimiter("\n");    
            pgrm.getJeu().nouveaujeu();
            pgrm.getJeu().getSudomodele().initialisationGrille(sc);            
        }
    }
 
    public void ouverturej() throws IOException{    
        try {
            FileInputStream fichier = new FileInputStream("sudomi.jeu");
            ObjectInputStream ois = new ObjectInputStream(fichier);    
            pgrm.getJeu().setSudomodele((Placement) ois.readObject());
        } 
        catch (java.io.IOException e) {
            e.printStackTrace();
        }
        catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        pgrm.getJeu().getSudomodele().observers.removeAll(pgrm.getJeu().getSudomodele().observers);    
        pgrm.reloadGUI(pgrm.getJeu().getSudomodele());        
        pgrm.getJeu().getSudomodele().notifyObservers();    
    }
 
    public void sauvegarde(){        
        try {
            FileOutputStream fichier = new FileOutputStream("sudomi.jeu");
            ObjectOutputStream oos = new ObjectOutputStream(fichier);
            oos.writeObject(pgrm.getJeu().getSudomodele());    
            oos.flush();
            oos.close();
        }
        catch (java.io.IOException e) {
            e.printStackTrace();
        }             
    }
}

C'est vrai que c'est plus net ainsi; y'a toujours ce passage par la classe Jeu qui me perturbe un peu ... Mais bon, on va pas chinoiser, c'est pas un projet d'UML que je dois rendre ...

J'ai beaucoup de mal avec les concepts abstraits et ça m'énerve d'autant plus quand je vois que certains jonglent avec :mrgreen: ...

Une fois encore, un tout tout grand merci pour ta précieuse aide !! ;)

24/05/2006, 15h36
le y@m's

Citation:

Envoyé par Mike888

J'ai beaucoup de mal avec les concepts abstraits et ça m'énerve d'autant plus quand je vois que certains jonglent avec :mrgreen: ...

C'est vrai que la conception ce n'est pas très évident au début (et même après :mrgreen: ), cependant elle est la partie la plus importante dans le développement d'une application (normalement au moins 30%).
Un bon moyen est de s'exercer sur de toute petites applications (là où le besoin de conception est beaucoup moins important mais aussi beaucoup plus "simple"), après ça vient aussi avec l'expérience ;) .