IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

avec Java Discussion :

Débutant en java - besoin d'un conseil


Sujet :

avec Java

  1. #1
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Février 2017
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Finance

    Informations forums :
    Inscription : Février 2017
    Messages : 25
    Points : 8
    Points
    8
    Par défaut Débutant en java - besoin d'un conseil
    Bonjour,
    Je débute en java et je travail sur un travail pratique relatif à un jeu de Sudoku. L'énoncé relatif à la première partie de mon travail se trouve ci-dessous.

    *****

    Créer des classes
    Le programme devra être développé autour de plusieurs classes soit :

    tn4.java permettant de démarrer le programme. Cette classe aura une méthode main qui devra faire comme actions :
    Créer une instance de la classe Sudoku9x9;
    Imprimer la grille de Sudoku original;
    Imprimer le degré de difficulté de la grille;
    Effectuer 10 placements;
    Imprimer la grille de Sudoku suite aux placements;
    Annuler 2 placements;
    Imprimer la grille de Sudoku suite à l’annulation;
    Valider la solution et imprimer le résultat de la validation.
    Sudoku.java, une classe abstraite représentant la notion abstraite de grille de Sudoku et des méthodes communes à tous les sous-types de grille de Sudoku. Elle aura donc comme attribut :
    Une matrice de nombre entier (int[][]) représentant la grille de Sudoku
    Une liste d’action de placement (Une ArrayList de classe Placement (voir plus bas))
    Le degré de complexité de la grille (int)
    L’attribut placement (int) indiquant le nombre de chiffre restant à placer dans la grille

    ****

    Mon code est le suivant :

    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
    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
    /*****************************************************************************/
    /* Classe tn4 contenant la méthode "main"                                    */ 
    /*****************************************************************************/
     
    package travailNote4;
     
    public class tn4 { 
     
      	public static void main(String[] args) { // Point d'entrée du programme
     
    		int [][] tab1 =     { { 0,3,9,1,0,0,0,6,4 },  // Création d'un tableau multidimensionnel débutant
                                { 0,6,0,7,4,0,0,9,5 },
                                { 7,5,0,0,0,3,2,8,0 },
                                { 6,0,0,2,0,0,0,1,0 },
                                { 0,1,5,0,6,9,0,0,0 },
                                { 0,2,8,4,0,7,0,0,0 },
                                { 5,7,0,0,2,0,0,3,0 },
                                { 0,4,0,0,0,0,0,0,0 },
                                { 0,8,1,5,0,0,0,4,0 } };
     
    		int [][] tab2 = 	{ { 0,0,0,0,0,0,0,0,0 },  // Création d'un tableau multidimensionnel intermédiaire
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 } };
     
            int [][] tab3 =     { { 0,0,0,0,0,0,0,0,0 },  // Création d'un tableau multidimensionnel expert
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 } };
     
        Sudoku9x9 jeu1 = new Sudoku9x9("Joueur1", 9, 10, 1);	// Instanciation de l'objet jeu1 dans la classe Sudoku9x9
     
     // Test méthodes - setGrille et getGrille
     
    		jeu1.setGrille(tab1); // Écriture de l'attribut dans l'objet jeu1
     
    		tab1 = jeu1.getGrille(); // Lecture de l'attribut de l'objet jeu1
     
    		System.out.println("-- Retourne la grille de Sudoku originale --"); // Impression de la grille de Sudoku originale
     
    		for (int i=0; i<jeu1.n; i++) {
     
    			System.out.print("\t"); // Alignement des colonnes
     
    			for (int j=0; j<jeu1.n; j++) {
     
    				System.out.print(tab1[i][j] + " ");
     
    			}
     
    			System.out.println();
     
    		}
     
    // Test les méthodes - getComplexite
     
            jeu1.setComplexite(1);
     
    		System.out.println();
    		System.out.println("-- Retourne le niveau de difficulté --"); // Impression du niveau de difficulté de la grille
    		System.out.println("\t" + jeu1.getComplexite());
    		System.out.println();
     
     
    // Test les méthodes - setTableaufinal et getTableaufinal
     
    		jeu1.setTableaufinal(tab3);
     
    		tab1 = jeu1.getTableaufinal();
     
    		System.out.println("-- Retourne le tableau --");
     
    		for (int i=0; i<jeu1.n; i++) {
     
    			System.out.print("\t");
     
    			for (int j=0; j<jeu1.n; j++) {
     
    				System.out.print(tab1[i][j] + " ");
     
    			}
     
    			System.out.println();
     
    		}
     
    		System.out.println();
     
     
    // Test la méthode - setGrille (unedonnee)
     
    		jeu1.setGrille(1, 2, 9); // par exemple, valeur 9 à la deuxième ligne, troisième colonne
     
    		tab1 = jeu1.getGrille();
     
    		System.out.println("-- Retourne la grille (unedonnee) --");
     
    		for (int i=0; i<jeu1.n; i++) {
     
    			System.out.print("\t");
     
    			for (int j=0; j<jeu1.n; j++) {
     
    				System.out.print(tab1[i][j] + " ");
     
    			}
     
    			System.out.println();
     
    		}
     
    		System.out.println();
     
     
    // Test les méthodes - setN et getN
     
    		jeu1.setN(9); // Écriture de l'attribut 9 dans l'objet jeu1
     
    		System.out.println("-- Retourne la dimension --");
    		System.out.println("\t" + jeu1.getN());
    		System.out.println();
     
     
    // Test les méthodes - setPlacements et getPlacements
     
    		jeu1.setPlacements(9);
     
    		System.out.println("-- Définit les placements --");
    		System.out.println("\t" + jeu1.getPlacements());	
    		System.out.println();
     
    			}
     
    		}
    Ma question est la suivante :

    >> Où dois-je mettre mes méthodes pour créer et annuler les placements? Mon impression est que ces méthodes ne doivent pas figurer dans ma classe main mais plutôt des la classe abstraite qui ne sera pas instance?

    Je me trompe?

    Merci infiniment pour votre aide.

    Salutations

  2. #2
    Modérateur
    Avatar de joel.drigo
    Homme Profil pro
    Ingénieur R&D - Développeur Java
    Inscrit en
    Septembre 2009
    Messages
    12 430
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D - Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2009
    Messages : 12 430
    Points : 29 131
    Points
    29 131
    Billets dans le blog
    2
    Par défaut
    Salut,

    Les méthodes de création et annulement de placement ne doivent évidemment pas être dans la classe "main", mais bien dans la classe abstraite Sudoku qu'on te demande de faire.

    De manière théorique, une classe abstraite n'a pas d'intérêt d'exister s'il n'existe pas d'implémentation concrète, puisqu'on ne peut pas l'instancier comme tu le remarques justement. Mais le but d'une classe abstraite est bien de mettre en place les implémentations génériques de manipulation de la classe, les parties spécifiques étant faites dans les implémentations concrètes. Une classe abstraite peut donc bien contenir des méthodes implémentées.

    Par exemple, une abstraction pour définir une liste d'éléments (oublions que List/AbstractList existe déjà) pourrait être :
    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
    public abstract class AbstractListe<T> {
     
    	public boolean contient(T item) {
    		for(int i=0; i<getTaille(); i++) {
    			if ( Objects.equals(item, get(i)) ) {
    				return true;
    			}
    		}
    		return false;
    	}
     
            public boolean estVide() {
                    return getTaille()==0;
            }
     
        public abstract int getTaille();
        public abstract T get(int index);
        public abstract void add(T item);
    }
    L'expression "ça marche pas" ne veut rien dire. Indiquez l'erreur, et/ou les comportements attendus et obtenus, et donnez un Exemple Complet Minimal qui permet de reproduire le problème.
    La plupart des réponses à vos questions sont déjà dans les FAQs ou les Tutoriels, ou peut-être dans une autre discussion : utilisez la recherche interne.
    Des questions sur Java : consultez le Forum Java. Des questions sur l'EDI Eclipse ou la plateforme Eclipse RCP : consultez le Forum Eclipse.
    Une question correctement posée et rédigée et vous aurez plus de chances de réponses adaptées et rapides.
    N'oubliez pas de mettre vos extraits de code entre balises CODE (Voir Mode d'emploi de l'éditeur de messages).
    Nouveau sur le forum ? Consultez Les Règles du Club.

  3. #3
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Février 2017
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Finance

    Informations forums :
    Inscription : Février 2017
    Messages : 25
    Points : 8
    Points
    8
    Par défaut Héritage de classe
    Salut joel.drigo,

    Merci pour ta réponse. Cela commence à s'éclaircir pour moi .... Donc si je comprends bien, ma classe abstraite Sudoku va contenir les méthodes de création et d'annulation de placements puisque ces méthodes sont communes aux sous-classes qui sont héritées de la classe mère Sudoku. Dans le case d'une sous-classe Sudoku9x9 je me pose maintenant les questions suivantes :

    1. La méthode qui définit les attributs de la grille de jeu (nom du joueur, taille de la grille, niveau de difficulté) appartient-elle à la classe abstraite Sudoku ou à la sous-classe Sudoku9x9 ?
    2. J'imagine que les méthodes d'initialisation de la grille et du niveau de complexité font partie de ma classe Sudoku?
    3. Les méthodes qui retournent le niveau de complexité, la grille, la dimension de la grille, le nombre de cases qu'il reste à placer et le retour du tableau final se mettent également dans la classe Sudoku?
    4. Même chose pour les méthodes qui valident la grille > dans la classe abstraite?

    Mille mercis pour ton aide, très apprécié !

    Cordialement,

  4. #4
    Modérateur
    Avatar de joel.drigo
    Homme Profil pro
    Ingénieur R&D - Développeur Java
    Inscrit en
    Septembre 2009
    Messages
    12 430
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D - Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2009
    Messages : 12 430
    Points : 29 131
    Points
    29 131
    Billets dans le blog
    2
    Par défaut
    Citation Envoyé par jalkhar Voir le message
    1. La méthode qui définit les attributs de la grille de jeu (nom du joueur, taille de la grille, niveau de difficulté) appartient-elle à la classe abstraite Sudoku ou à la sous-classe Sudoku9x9 ?
    Cela dépent.
    1. si un attribut représente une notion standard, commune donc au comportement de la classe abstraite, ou fonctionnelle, il devrait être dans la classe abstraite.
    2. si un attribut peut être de plusieurs types différents, il sera plutôt dans l'implémentation concrète et la classe abstraite proposera une méthode pour en obtenir la valeur.

    Ensuite, il faut réfléchir à la nécessité d'un attribut. Par exemple, la taille d'une grille ne sert qu'à initialiser le tableau, et ensuite on peut obtenir la taille par le tableau lui-même. Pas besoin nécessairemnt de stocker un attribut. Par exemple, si on veut faire une classe qui permet de gérer des grilles génériquement, dont on sait qu'elles peuvent être petites, ou plus grandes, mais peu remplies, on peut vouloir prévoir une implémentation qui permet une implémentation pour économiser de la mémoire :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    public abstract class AbstractGrid<T> {
      public abstract int size();
    }
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class ArrayGrid<T> {
      private final T[][] grid;
      public ArrayGrid(int size) {
          grid=new Object[size][size];
      }
      public int size() {
          return grid.length;
      }
    }
    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
     
    public class MapGrid<T> {
      private final Map<Coor,T> grid;
      private final int size;
      public ArrayGrid(int size) {
          this.size=size;
          grid=new HashMap<>(size*size);
      }
      public int size() {
          return size;
      }
      private static class Coor {
          private final int x;
          private final int y;
          private final int hash;
          public Coor(int x, int y) {
              this.x=x;
              this.y=y;
              this.hash=Objects.hash(x,y);
          }
          public int hashCode() {
              return hash;
          }
          public boolean equals(Object obj) {
              if ( obj instanceof Coor ) {
                   Coor coor = (Coor)obj;
                   return coor.x==x && coor.y==y;
              }
              return false;
          }
      }
    }
    Citation Envoyé par jalkhar Voir le message
    2. J'imagine que les méthodes d'initialisation de la grille et du niveau de complexité font partie de ma classe Sudoku?
    3. Les méthodes qui retournent le niveau de complexité, la grille, la dimension de la grille, le nombre de cases qu'il reste à placer et le retour du tableau final se mettent également dans la classe Sudoku?
    4. Même chose pour les méthodes qui valident la grille > dans la classe abstraite?
    Au moins les signatures abstraites, à priori, s'il s'agit d'une notion fonctionnelle de la notion de grille de sudoku. L'implémentation pourra être dans la classe abstraite ou la classe concrète, selon l'implémentation. La manipulation de la grille de sudoku va se faire de manière générique par le type abstraite : toutes les méthodes nécessitant ces manipulations doivent donc être accessibles par la classe abstraite, donc est au moins déclarée abstraite dans la classe abstraite.
    On ne doit pas avoir à faire des trucs dans le genre :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    if ( grille instanceof ImplementationConcrete1 ) {
          ((ImplementationConcrete1)grille).methodeSpecifique1();
    } else if ( grille instanceof ImplementationConcrete2 ) {
          ((ImplementationConcrete2)grille).methodeSpecifique2();
    }
    Mais
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    grille.methodeGenerique();
    Et on pourra avoir :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    public abstract class AbstractExemple {
        public abstract void methodeGenerique();
    }
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    public abstract class AbstractExemple {
        public abstract void methodeGenerique();
    }
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    public class ImplementationConcrete1 extends AbstractExemple {
        public void methodeGenerique() {
            methodeSpecifique1();
        }
        public void methodeSpecifique1() {
               // ...
        }
    }
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    public class ImplementationConcrete2 extends AbstractExemple {
        public void methodeGenerique() {
            methodeSpecifique2();
        }
        public void methodeSpecifique2() {
               // ...
        }
    }
    L'expression "ça marche pas" ne veut rien dire. Indiquez l'erreur, et/ou les comportements attendus et obtenus, et donnez un Exemple Complet Minimal qui permet de reproduire le problème.
    La plupart des réponses à vos questions sont déjà dans les FAQs ou les Tutoriels, ou peut-être dans une autre discussion : utilisez la recherche interne.
    Des questions sur Java : consultez le Forum Java. Des questions sur l'EDI Eclipse ou la plateforme Eclipse RCP : consultez le Forum Eclipse.
    Une question correctement posée et rédigée et vous aurez plus de chances de réponses adaptées et rapides.
    N'oubliez pas de mettre vos extraits de code entre balises CODE (Voir Mode d'emploi de l'éditeur de messages).
    Nouveau sur le forum ? Consultez Les Règles du Club.

  5. #5
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Février 2017
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Finance

    Informations forums :
    Inscription : Février 2017
    Messages : 25
    Points : 8
    Points
    8
    Par défaut
    OK merci ! Voici comment j'ai structuré mon programme.
    Classe tn4 qui contient ma méthode "main" et les tests de toutes mes méthodes
    Classe abstraite mère Sudoku qui contient ce que je considère comme méthodes communes
    Classe instanciée Sudoku9x9.

    Puis-je te demander ton avis sur la cohérence de ce code? J'ai essayé de documenté le mieux possible pour faciliter la lecture ... Merci encore !!

    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
    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
    150
    151
    152
    153
    **************
     
    /*****************************************************************************/
    /* Nom du programme: Sudoku                                                                                             */
    /* Fichier : tn4.java                                                                                                              */
    /* Description :                                                                                                                    */
    /* Auteur :                                                                                                                           */
    /*****************************************************************************/
     
    /*****************************************************************************/
    /* Classe tn4 contenant la méthode "main"                                    */ 
    /*****************************************************************************/
     
    package travailNote4;
     
    public class tn4 { 
     
      	public static void main(String[] args) { // Point d'entrée du programme
     
    		int [][] tab1 =     { { 0,3,9,1,0,0,0,6,4 },  // Création d'un tableau multidimensionnel débutant
                                { 0,6,0,7,4,0,0,9,5 },
                                { 7,5,0,0,0,3,2,8,0 },
                                { 6,0,0,2,0,0,0,1,0 },
                                { 0,1,5,0,6,9,0,0,0 },
                                { 0,2,8,4,0,7,0,0,0 },
                                { 5,7,0,0,2,0,0,3,0 },
                                { 0,4,0,0,0,0,0,0,0 },
                                { 0,8,1,5,0,0,0,4,0 } };
     
    		int [][] tab2 = 	{ { 0,0,0,0,0,0,0,0,0 },  // Création d'un tableau multidimensionnel intermédiaire
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 } };
     
            int [][] tab3 =     { { 0,0,0,0,0,0,0,0,0 },  // Création d'un tableau multidimensionnel expert
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 },
                                { 0,0,0,0,0,0,0,0,0 } };
     
        Sudoku9x9 jeu1 = new Sudoku9x9("Joueur1", 9, 10, 1);	// Instanciation de l'objet jeu1 dans la classe Sudoku9x9
     
     // Test méthodes - setGrille et getGrille
     
    		jeu1.setGrille(tab1); // Écriture de l'attribut dans l'objet jeu1
     
    		tab1 = jeu1.getGrille(); // Lecture de l'attribut de l'objet jeu1
     
    		System.out.println("-- Retourne la grille de Sudoku originale --"); // Impression de la grille de Sudoku originale
     
    		for (int i=0; i<jeu1.n; i++) {
     
    			System.out.print("\t"); // Alignement des colonnes
     
    			for (int j=0; j<jeu1.n; j++) {
     
    				System.out.print(tab1[i][j] + " ");
     
    			}
     
    			System.out.println();
     
    		}
     
    // Test les méthodes - getComplexite
     
            jeu1.setComplexite(1);
     
    		System.out.println();
    		System.out.println("-- Retourne le niveau de difficulté --"); // Impression du niveau de difficulté de la grille
    		System.out.println("\t" + jeu1.getComplexite());
    		System.out.println();
     
     
    // Test les méthodes - setTableaufinal et getTableaufinal
     
    		jeu1.setTableaufinal(tab3);
     
    		tab1 = jeu1.getTableaufinal();
     
    		System.out.println("-- Retourne le tableau --");
     
    		for (int i=0; i<jeu1.n; i++) {
     
    			System.out.print("\t");
     
    			for (int j=0; j<jeu1.n; j++) {
     
    				System.out.print(tab1[i][j] + " ");
     
    			}
     
    			System.out.println();
     
    		}
     
    		System.out.println();
     
     
    // Test la méthode - setGrille (unedonnee)
     
    		jeu1.setGrille(1, 2, 9); // par exemple, valeur 9 à la deuxième ligne, troisième colonne
     
    		tab1 = jeu1.getGrille();
     
    		System.out.println("-- Retourne la grille (unedonnee) --");
     
    		for (int i=0; i<jeu1.n; i++) {
     
    			System.out.print("\t");
     
    			for (int j=0; j<jeu1.n; j++) {
     
    				System.out.print(tab1[i][j] + " ");
     
    			}
     
    			System.out.println();
     
    		}
     
    		System.out.println();
     
     
    // Test les méthodes - setN et getN
     
    		jeu1.setN(9); // Écriture de l'attribut 9 dans l'objet jeu1
     
    		System.out.println("-- Retourne la dimension --");
    		System.out.println("\t" + jeu1.getN());
    		System.out.println();
     
     
    // Test les méthodes - setPlacements et getPlacements
     
    		jeu1.setPlacements(10);
     
    		System.out.println("-- Définit les placements --");
    		System.out.println("\t" + jeu1.getPlacements());	
    		System.out.println();
     
    			}
     
    		}
    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
    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
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    /*****************************************************************************/
    /* Classe abstraite Sudoku                                                                                                     */ 
    /*****************************************************************************/
     
    // La classe Sudoku est la classe mère qui contient les attributs communs à toutes les classes filles (Sudoku9x9 par exemple)
    // Cette technique d'héritage permet d'instancier la classe fille Sudoku9x9 plutôt que la classe mère.
     
    package classeAbstraite;
     
    import java.util.ArrayList;
    import java.util.BitSet;
     
    public abstract class Sudoku { // Création de la classe Sudoku qui n'est pas instanciée. 
     
        private int[][] tableaufinal; // Matrice de nombre entier qui représente la grille finale de Sudoku
        private int [][] grille; // Matrice de nombre entier qui représente la grille de Sudoku
        private int complexite = 0; // Variable pour enregistrer le niveau de difficulte 1 à 3
        private int placements = 0; // Nombre de chiffre restant à placer dans la grille
        private int n; // Représente le nombre d'éléments dans le Sudoku 
        private String nom; // Représente le nom du joueur
     
        private List<Placement> placements = new ArrayList<Placement> (); // Création d'un nouvel objet dynamique ArrayList "Placement" vide
     
     	// Constructeur de Sudoku - Définition des attributs de la classe Sudoku
     
     		public Sudoku (String nom, int n, int placements, int complexite) {
     
     			this.n = n;
     
    			grille = new int[n][n]; // La grille est composée de n * n carrés
     
    	// Fonction d'initialisation des valeurs de la grille, du niveau de complexité et des placements à zéro
     
    		public void initialisation () {
     
    			for (int i=0; i<n; i++) {
     
    				for (int j=0; j<n; j++) {
     
    					grille[i][j] = 0;
     
    				}
    			}
     
    			complexite = 0;
     
    			placement = 0;
     
    		}
     
    	// Classe Placement qui permet de connaître le nombre de chiffre restant à placer dans la grille
     
    		public class Placement {
     
        		private int value = 0;
        		private int x = 0;
        		private int y = 0;
        		private int nouvelleValeur = 0;
        		private int ancienneValeur = 0;
     
        		public Placement(int x, int y, int ancienneValeur,int nouvelleValeur) {
            		this.x = x;
            		this.y = y;
            		this.ancienneValeur = ancienneValeur;
            		this.nouvelleValeur = nouvelleValeur;
     
        		}
     
        		public int getX() {
            		return this.x;
        		}
     
        		public int getY() {
            		return this.y;
        		}
     
        		public int getancienneValeur() {
            		return this.ancienneValeur;
        		}
     
        		public int getnouvelleValeur() {
            		return this.nouvelleValeur;
        		}
     
    		}
     
    	// Classe creerPlacement
     
    			public void creerPlacement(int x, int y, int valeur){
     
            		Placement deplocal=new Placement(x,y,this.grille[x][y],valeur);
     
        				this.ListPlacements.add(deplocal);
            			this.grille[x][y]=valeur;
     
         		}
     
     	// Classe annulerPlacement
     
         		public void annulerPlacement() {
     
            		Placement deplocal=(Placement)this.ListPlacements.get(this.ListPlacements.size()-1);  
     
            			int x = deplocal.getX();
            			int y = deplocal.getY();
            			int ancienneValeur = deplocal.getancienneValue();
            			this.grille[x][y]=ancienneValeur;
     
            			this.ListPlacements.remove(this.ListPlacements.size()-1);
     
         		}
     
    	// Méthode d'impression de la grille originale
     
        		public void imprimerGrilleOriginale() {
     
    				System.out.println("imprime");
     
        			}
     
        		public void imprimerComplexite() {
     
            		System.out.println("Degre de complexite : " + complexite);
     
        		}
     
    /******************************************************************************/
    /* Section dédiée à la validation de la grille (dans classe Sudoku)                                               */ 
    /******************************************************************************/
     
    public boolean validate() {
    // un tableau : int[][] tableauFinal = new int[9][9]();
    // initialisation et actions sur le Sudoku
    // Vérifie les lignes et les colonnes 
     
    	for (int i = 0; i < tableauFinal.length; i++) {
     
    		BitSet bsRow = new BitSet(9);
     
    		BitSet bsColumn = new BitSet(9);
     
    			for (int j = 0; j < tableauFinal[i].length; j++) {
     
    				if (tableauFinal[i][j] == 0 || tableauFinal[j][i] == 0) continue;
     
    					if (bsRow.get(tableauFinal[i][j] - 1) || bsColumn.get(tableauFinal[j][i] - 1))
     
    					return false;
     
    						else {
     
    							bsRow.set(tableauFinal[i][j] - 1);
     
    							bsColumn.set(tableauFinal[j][i] - 1);
     
    							}
     
    						}
     
    					}
     
    // Vérifie les quadrans (3x3)
     
    	for (int rowOffset = 0; rowOffset < 9; rowOffset += 3) {
     
    		for (int columnOffset = 0; columnOffset < 9; columnOffset += 3) {
     
    			BitSet threeByThree = new BitSet(9);
     
    				for (int i = rowOffset; i < rowOffset + 3; i++) {
     
    					for (int j = columnOffset; j < columnOffset + 3; j++) {
     
    						if (tableauFinal[i][j] == 0) continue;
     
    							if (threeByThree.get(tableauFinal[i][j] - 1))
     
    								return false;
     
    							else
     
    							threeByThree.set(tableauFinal[i][j] - 1);
     
    							}
     
    						}  
     
    					}
     
    				}
     
    		return true;
     
    	}
     
    }
    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
    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
    /*****************************************************************************/
    /* Classe Sudoku9x9                                                          */ 
    /*****************************************************************************/
     
    // La classe Sudoku 9x9 hérite de la classe mère abstraite Sudoku et constitue donc une sous-classe de Sudoku
    // On peut dire que Sudoku 9x9 est un cas particulier de Sudoku
    // On peut ainsi créer n'importe quel cas particulier (Sudoku15x15 par exemple) en utilisant les attributs de la classe abstraite Sudoku
     
     
    package sous_Classe;
     
    import java.util.BitSet; // Importation package utilitaire permettant de créer un vecteurs de bits
     
    	public class Sudoku9x9 extends Sudoku  { // Création de la classe Sudoku 9x9 dérivée de la classe abstraite Sudoku
     
    		public Sudoku9x9 (String nom, int n, int placement, int complexite){ // Définition des attributs de la classe Sudoku 9x9
     
    		 this.n = n;
     
    		 grille = new int[n][n];
     
    		 initialisation ();
     
    	 }
     
     
     public int getComplexite() { // Retourne le niveau de complexité
     
    		return complexite;
     
    	}
     
     public int[][] getGrille() { // Retourne la grille
     
    		return grille;
     
    	}
     
     public void setComplexite(int complexite) {
     
    	this.complexite = complexite;
     
    	}
     
    public void setGrille(int i, int j, int unedonnee) { // Définit "une unedonnee" à la ligne i et colonne j de la grille
     
    		this.grille[i][j] = unedonnee;
     
    	}	
     
    public int getN () { // Retourne la dimension de la grille
     
    		return n;
     
    	}
     
    public void setN(int n) { // Définit la dimension de la grille
     
    		this.n = n;
     
    	}
     
    public int getPlacements() { // Retourne la valeur lesplacements
     
    		return placements;
     
    	}
     
     
    public void setPlacements(int placements) { // Définit la valeur lesplacements
     
    		this.placements = placements;
     
    	}
     
    public void setTableaufinal(int[][] tableaufinal) { // Définit le tableau final
     
    	this.tableaufinal = tableaufinal;
     
    	}
     
     
    public void setGrille(int[][] grille) { // Définit la grille
     
    	this.grille = grille;
     
    	}
     
     
    public int[][] getTableaufinal() { // Retourne le tableau final
     
    	return tableaufinal;
     
    	}
     
    *************************************************

  6. #6
    Rédacteur/Modérateur

    Avatar de bouye
    Homme Profil pro
    Information Technologies Specialist (Scientific Computing)
    Inscrit en
    Août 2005
    Messages
    6 838
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : Nouvelle-Calédonie

    Informations professionnelles :
    Activité : Information Technologies Specialist (Scientific Computing)
    Secteur : Agroalimentaire - Agriculture

    Informations forums :
    Inscription : Août 2005
    Messages : 6 838
    Points : 22 846
    Points
    22 846
    Billets dans le blog
    51
    Par défaut
    Merci d'utiliser la balise quand tu tape du code.
    Merci de penser au tag quand une réponse a été apportée à votre question. Aucune réponse ne sera donnée à des messages privés portant sur des questions d'ordre technique. Les forums sont là pour que vous y postiez publiquement vos problèmes.

    suivez mon blog sur Développez.

    Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the universe trying to produce bigger and better idiots. So far, the universe is winning. ~ Rich Cook

  7. #7
    Modérateur
    Avatar de joel.drigo
    Homme Profil pro
    Ingénieur R&D - Développeur Java
    Inscrit en
    Septembre 2009
    Messages
    12 430
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D - Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2009
    Messages : 12 430
    Points : 29 131
    Points
    29 131
    Billets dans le blog
    2
    Par défaut
    Salut,

    Je vois plusieurs problèmes dans ton code (liste non exhaustive), en dehors du fait qu'il faudrait avant tout que ça compile :

      1. Il y a des traitements dédoublés entre abstraction et classe concrète : il y'en a forcément un de trop.
        Par exemple, le tableau grille est une notion gérée par la classe abstraite : la variable grille est déclarée dans cette classe. La taille, la variable n, aussi. Dans le constructeur, tu crées cette grille (tu construis le tableau à 2 dimensions avec la valeur de la variable n). Mais tu le refais dans la classe concrète : c'est inutile et superfétatoire. Idem pour l'initialisation. D'ailleurs, premier point qui ne compile pas : tu ne peux même le faire, la variable grille est private, donc inaccessible depuis la classe concrète.
      2. Le constructeur permet de passer une complexité : le paramètre est complètement ignoré, et même forcé à zéro lors de l'initialisation. L'initialisation d'ailleurs qui n'est pas appelée par le constructeur de la classe abstraite. A noter que la complexité ne devrait pas être intialisée par la méthode initialisation : la méthode est public, donc appellable n'importe quand, je suppose pour faire un reset de la partie. Fonctionnellement, en faisant un reset de la partie, il n'y a aucune raison de changer la complexité. Au passage, les variables primitives étant par défaut initialisées à zéro, c'est inutile de le faire pendant la construction. De la même façon, un tableau de primitifs est aussi rempli de 0, donc inutile de le faire lors de la construction.
      3. Je n'ai pas lu en détail ton algorithme de validation, mais il me semble que traiter le [i][j] et [j][i] dans la même boucle pose un problème de part cette condition : if (tableauFinal[i][j] == 0 || tableauFinal[j][i] == 0) continue;. Si tu as en 2,3 un nombre!=0, et en 3,2, tu as 0, le nombre en 2,3 est totalement ignoré par la validation. Idem pour if (bsRow.get(tableauFinal[i][j] - 1) || bsColumn.get(tableauFinal[j][i] - 1)) return false;. Si tu traites 2,3, tu vas traiter 3,2 après (i=2, puis i=3). Donc au premier passage, si on a mettons 9 dans 2,3 et 3,2, alors la grille est invalide. Est-ce vraiment une règle du sudoku ? Et puis à quoi sert cette validation au juste ? A valider un placement ? Inutile de traiter toute la grille dans ce cas. Il suffit de traiter la ligne, la colonne et le quadrant auquel appartient la case placée. Et pour savoir si le joueur a trouvé la grille, une comparaison avec tableauFinal suffira.

    1. Une classe se doit d'être une forme de boite noire : elle a un comportement, ce comportement doit être cohérent, l'extérieur n'a pas à savoir comment est réalisé ce comportement, et, surtout, ne doit pas interférer avec ce comportement.
      1. Par exemple, tu permets de modifier n, la taille de la grille, sans même modifier le tableau : tu obtiens donc une instance incohérente. On ne devrait pas avoir de méthode setN() (qui aurait dû s'appeler setTaille() plutôt, ou setSize()). De la même façon setComplexité() ne devrait pas exister, ou alors ça devrait provoquer une réinitialisation (de la complexité dépend le nombre de case préremplies au début du jeu en théorie). Pire, setPlacements() permet de modifier ce qu'il semble être un nombre de placements qu'il reste à effectuer (le nombre de case vide) : c'est à la classe de gérer ça, pas à l'extérieur de la classe. En fait, c'est le nombre de cases de la grille moins la taille de la liste de Placement : inutile d'avoir un attribut, qui a de fortes chances de devenir incohrent par rapport au nombre de placement, mais s'il faut un attribut (ce que le sujet semble demandé, il suffit de l'initialiser au début, et de le décrémenter à chaque placement et de l'incrémenter à chaque annulation de placement, ou de le calculer (la différence que j'ai dit).
      2. On peut forcer la grille, indépendemment de la liste de placement, par la méthode setGrille(), avec la taille qu'on veut, donc tout saborder (sans parler de tricher). Pire encore, on peut faire setTableauFinal n'importe quand, avec une grille qui n'a pas du tout la bonne taille.
      3. Qu'on puisse donner sous forme de tableau la grille initiale ne veut pas dire qu'on doive l'utiliser directement ce tableau comme grille de référence : déjà, le risque est qu'on modifie le tableau de l'extérieur, n'importe quand, mais si la grille n'a pas la bonne taille, on n'aura des problèmes de fonctionnement. Les classes extérieures ne devrait même pas savoir que la grille est stockée sous forme de tableau à 2 dimensions. Que cela soit un moyen de communiquer avec l'extérieur n'implique pas que cela soit le stockage interne : en tout cas, l'extérieur ne doit surtout pas pouvoir manipuler directement les attributs internes, d'autant plus que tout cela correspond à une classe à état (changer l'état n'importe comment ne peut que rendre incohérent l'ensemble du comportement de la classe).


    Dans les détails, tu pourrais gérer les placements par Deque plutôt que par List, ce qui simplifierait ton code :

    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
     
    private Deque<Placement> placements = new ArrayDeque<>();
    public void creerPlacement(int x, int y, int valeur){
     
        Placement deplocal=new Placement(x,y,this.grille[x][y],valeur);
     
        this.placements.push(deplocal);
        this.grille[x][y]=valeur;
     
        // il manque bien sûr la validation du coup
     
    }
     
    public void annulerPlacement() {
     
        if ( !placements.isEmpty() )  { // s'il y a des placements
            Placement deplocal= placements.pop();
     
    	int x = deplocal.getX();
    	int y = deplocal.getY();
    	int ancienneValeur = deplocal.getancienneValeur();
    	this.grille[x][y]=ancienneValeur;
            // à noter qu'on peut écrire juste : this.grille[deplocal.getX()][deplocal.getY()]=deplocal.getancienneValeur();
     
        }
     
    }
    L'expression "ça marche pas" ne veut rien dire. Indiquez l'erreur, et/ou les comportements attendus et obtenus, et donnez un Exemple Complet Minimal qui permet de reproduire le problème.
    La plupart des réponses à vos questions sont déjà dans les FAQs ou les Tutoriels, ou peut-être dans une autre discussion : utilisez la recherche interne.
    Des questions sur Java : consultez le Forum Java. Des questions sur l'EDI Eclipse ou la plateforme Eclipse RCP : consultez le Forum Eclipse.
    Une question correctement posée et rédigée et vous aurez plus de chances de réponses adaptées et rapides.
    N'oubliez pas de mettre vos extraits de code entre balises CODE (Voir Mode d'emploi de l'éditeur de messages).
    Nouveau sur le forum ? Consultez Les Règles du Club.

  8. #8
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Février 2017
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Finance

    Informations forums :
    Inscription : Février 2017
    Messages : 25
    Points : 8
    Points
    8
    Par défaut Merci pour ces réponses aussi détaillées !
    Contre toute attente, je crois que je commence à comprendre, j'espère ne pas m'avancer trop vite

    1. Je vais effectivement restructurer ma classe concrète (Sudoku9x9) pour n'y laisser que son instantiation.
    2. J'ai inclus la complexité dans la méthode d'initialisation car c'est demandé dans mon exercice. Je te concède cependant que le fait de faire un reset de la partie ne devrait pas impliquer un reset du niveau de complexité ...
    3. L'algorithme de validation nous a été donné dans l'énoncé également.
    4. Si je comprends ce que tu dis dans ton deuxième point, je pourrais mettre mes méthodes SetN et SetComplexite dans ma classe principal. Je pense avoir lu quelque part qu'un changement de taille provoquerait une mise à jour de la taille du tableau qui est sous une forme dynamique ...
    5. J'aime ton algorithme de création de placement. Quelle est la différence entre ".add(deplocal)" et ".push(delpocal)" ?

    Il m'est aussi demandé de construire la classe suivante "Case.java, une classe représentant une case de la grille. Cette classe sera utilisée par la méthode placement et annuler placement afin de garder un trace des actions sur la grille de jeu. À vous de déterminer quels sont ces attributs et méthodes pour répondre aux besoins de la problématique. À vous également de spécifier sa visibilité et de la justifier."

    >> Je ne comprends pas la question. Plus précisément, en quoi cette classe est-elle différente de ma classe creerPlacement. N'est-ce pas justement creerPalcement qui va garder une trace de toutes les actions entreprises par le joueur?

    Merci encore pour ta patience !

    Cordialement,

  9. #9
    Modérateur
    Avatar de joel.drigo
    Homme Profil pro
    Ingénieur R&D - Développeur Java
    Inscrit en
    Septembre 2009
    Messages
    12 430
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D - Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2009
    Messages : 12 430
    Points : 29 131
    Points
    29 131
    Billets dans le blog
    2
    Par défaut
    Citation Envoyé par jalkhar Voir le message
    2. J'ai inclus la complexité dans la méthode d'initialisation car c'est demandé dans mon exercice. Je te concède cependant que le fait de faire un reset de la partie ne devrait pas impliquer un reset du niveau de complexité ...
    C'est en effet une option, mais pas juste pour la mettre à 0 alors qu'on la passe par ailleurs dans la construction, puisque le résultat et que quoiqu'on passe comme valeur dans la construction, on a toujours une complexité de 0.
    Je peux imaginer qu'on ait une méthode intialisation comme ça :
    Code pseudojava : 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
     
    public void initialisation(int complexite) {
     
            int nombreDeCasesVides = fonctionSpecialeADeterminer(complexite); // on déterminer un nombre de case initialement vide en fonction de la complexité
     
            copier tableauFinal vers grille // double boucle et copie case par case
     
            for(int i=0; i<nombreDeCasesVides; i++) {
     
                    // tirer une case au hasard non vide
                    do {
                            tirer un x au hasard
                            tirer un y au hasard
                    } while ( grille[x][y] !=0 )
     
                    grille[x][y]=0; // vider la case
     
            }
     
     
    }

    Citation Envoyé par jalkhar Voir le message
    3. L'algorithme de validation nous a été donné dans l'énoncé également.
    Hum, vraiment... l'algorithme ou le code ? Je serais curieux de voir ce qu'on vous a donné exactement. Ce qui m'étonne en plus du fait que ça ne me semble pas fonctionner pour les raisons que j'avais énoncées, c'est le fait qu'on fasse référence à des quadrants en dur. A moins qu'il ne s'agisse de l'implémentation dans la classe concrète Sudoku9x9, s'il s'agit d'une validation de n'importe quelle grille, des quadrants de 9 cases (3x3) risquent de difficilement fonctionner sur une grille mettons de 5 par 5...

    Citation Envoyé par jalkhar Voir le message
    4. Si je comprends ce que tu dis dans ton deuxième point, je pourrais mettre mes méthodes SetN et SetComplexite dans ma classe principal.
    non, ce que je voulais dire, c'est que ces méthodes ne devraient pas exister. On ne peut pas changer la taille de la grille n'importe quand et n'importe comment. Si ta classe s'appelle Sudoku9x9, c'est qu'elle gère une grille de 9 par 9 : appeler setN(42) va faire qu'elle fait tout d'un coup soi-disant 42 par 42, ce qui est abscons. Je dis soi-disant par ce que ce n'est pas en changeant n que ça va changer quoique ce soit au niveau de la taille de grille, tableauFinal ou autre... le problème est que la méthode getN() qui devrait en toute logique s'appeler plutôt getTaille() est censée pouvoir être utilisée par quelqu'un qui veut pouvoir connaître la taille de la grille, par exemple pour l'afficher, et que cette méthode retourne la valeur de n.
    Donc si tu fais un code comme ça:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    Sudoku9x9 jeu = new Sudoku9x9(/*je passe sur les paramètres*/);
    jeu.setN(42);
    System.out.println("La taille de la grille est : " + jeu.getN() + " × " + jeu.getN()+".");
    Tu obtiens un résultat complètement faux.
    Citation Envoyé par jalkhar Voir le message
    Je pense avoir lu quelque part qu'un changement de taille provoquerait une mise à jour de la taille du tableau qui est sous une forme dynamique ...
    Pas en Java en tout cas.

    • Tout d'abord un tableau en Java est toujours de taille fixe
    • Certains appellent la classe ArrayList un tableau dynamique (ce que je pense être biaisé, déjà parce qu'on attribut un comportement à une implémentation interne dont on n'a normalement pas à soucier fonctionnellement). Pour diverses raisons (performance / mémoire) on choisit d'utiliser une implémentation à base de tableau, mais on manipule une List, point barre.
    • On ne modifie pas le nombre d'élément d'une liste (List) en modifiant sa taille par appel d'une méthode : on ajoute des éléments, on en retire.

    Bien sûr, on peut écrire une classe qui gèrerait ce qui pourrait ressembler vaguement à un tableau de taille variable, avec une méthode setSize(). On peut aussi utiliser Arrays.copyOf() tout simplement.
    En ce qui concerne le sudoku, ce n'est pas seulement un problème avec la taille de la grille : en dehors du fait qu'avec une classe Sudoku9x9 c'est abscons, le tableauFinal deviendrait caduque (il ne suffit pas d'en changer la taille, il faut aussi que son contenu suivent), les placements devriendraient incohérent, etc... on pourrait faire un SudokyDynamic, mais le changement de taille ne devrait passer que par l'initialisation, initialisation qui devrait avoir en paramètre la grille finale. D'ailleurs la taille pourrait tout simplement venir de la grille finale.

    Citation Envoyé par jalkhar Voir le message
    5. J'aime ton algorithme de création de placement. Quelle est la différence entre ".add(deplocal)" et ".push(delpocal)" ?
    push() est une méthode de Deque qui place l'élement au début. Une Deque est, en partie, ce qu'on appelle une pile. Une pile a un comportement LIFO. C'est particulièrement adapté à un système de undo. On veut toujours annuler le dernier placerment effectué, donc on est bien en LIFO et pas en FIFO, ou en random comme dans une List. Malheureusement, en relisant ton extrait d'enoncé je vois qu'on t'impose d'utiliser une ArrayList. Avec une ArrayList, tu à le choix entre :

    1. une écriture un peu compliqué et fastidieuse de récupération de la fin :
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      Placement dernier = placements.get(placements.size()-1);
      En revanche, tu peux simplifier dans ton code l'écriture de la suppression, en écrivant directement :
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      Placement dernier = placements.remove(placements.size()-1);
    2. une écriture plus concise mais une exécution moins performante, en ajoutant non pas à la fin mais au début
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      placements.add(0, placement);
      et pour la suppression
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      Placement placement = placements.remove(0);
    3. Ou gérer le comportement en utilisant une seconde variable (ce qui mériterait éventuellement d'être encapsulé dans une classe dédiée, qu'on pourrait à la rigueur appeler tableau dynamique) :
      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
      private List<Placement> placements = new ArrayMList<>();
      private int nbPlacements = 0;
      public void creerPlacement(int x, int y, int valeur){
       
          Placement deplocal=new Placement(x,y,this.grille[x][y],valeur);
       
          if ( this.placements.size()<=nbPlacements ) {
               this.placements.add(nbPlacements++, deplocal);  
          }
          else {
               this.placements.set(nbPlacements++, deplocal); 
          }
          this.grille[x][y]=valeur;
       
      }
       
      public void annulerPlacement() {
       
          if ( nbPlacements>0 )  { // s'il y a des placements
              Placement deplocal = placements.set(--nbPlacements,null);
       
      	int x = deplocal.getX();
      	int y = deplocal.getY();
      	int ancienneValeur = deplocal.getancienneValeur();
      	this.grille[x][y]=ancienneValeur; 
       
          }
       
      }
      Bien sûr le nombre de placements n'est plus la taille de placements, mais bien nbPlacements.




    Citation Envoyé par jalkhar Voir le message
    Il m'est aussi demandé de construire la classe suivante "Case.java, une classe représentant une case de la grille. Cette classe sera utilisée par la méthode placement et annuler placement afin de garder un trace des actions sur la grille de jeu. À vous de déterminer quels sont ces attributs et méthodes pour répondre aux besoins de la problématique. À vous également de spécifier sa visibilité et de la justifier."

    >> Je ne comprends pas la question. Plus précisément, en quoi cette classe est-elle différente de ma classe creerPlacement. N'est-ce pas justement creerPalcement qui va garder une trace de toutes les actions entreprises par le joueur?
    Ici, on te décrit une classe qui est censé stocker le contenu d'une case. Actuellement, avec ton système de int[][], tu stockes le contenu d'une case, un int, directement dans le tableau. On te demande de remplacer le int par une instance de Case.
    Donc, là où tu as dans ta méthode creerPlacement, this.grille[x][y]=valeur;, tu vas avoir un appel de méthode de la classe Case à la place, sur l'instance représentant la case de coordonnées x,y.
    L'expression "ça marche pas" ne veut rien dire. Indiquez l'erreur, et/ou les comportements attendus et obtenus, et donnez un Exemple Complet Minimal qui permet de reproduire le problème.
    La plupart des réponses à vos questions sont déjà dans les FAQs ou les Tutoriels, ou peut-être dans une autre discussion : utilisez la recherche interne.
    Des questions sur Java : consultez le Forum Java. Des questions sur l'EDI Eclipse ou la plateforme Eclipse RCP : consultez le Forum Eclipse.
    Une question correctement posée et rédigée et vous aurez plus de chances de réponses adaptées et rapides.
    N'oubliez pas de mettre vos extraits de code entre balises CODE (Voir Mode d'emploi de l'éditeur de messages).
    Nouveau sur le forum ? Consultez Les Règles du Club.

  10. #10
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Février 2017
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Finance

    Informations forums :
    Inscription : Février 2017
    Messages : 25
    Points : 8
    Points
    8
    Par défaut
    Hum, vraiment... l'algorithme ou le code ? Je serais curieux de voir ce qu'on vous a donné exactement. Ce qui m'étonne en plus du fait que ça ne me semble pas fonctionner pour les raisons que j'avais énoncées, c'est le fait qu'on fasse référence à des quadrants en dur. A moins qu'il ne s'agisse de l'implémentation dans la classe concrète Sudoku9x9, s'il s'agit d'une validation de n'importe quelle grille, des quadrants de 9 cases (3x3) risquent de difficilement fonctionner sur une grille mettons de 5 par 5...
    Désolé pour mon imprécision. C'est bien le code qui nous a été donné. Copie ci-dessous. Ta remarque est une fois de plus super pertinente. Il faut sans doute inclure la méthode de validation dans la classe Sudoku9x9 sans quoi le code ne fonctionnerait effectivement pas ...

    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
    62
    63
    64
    65
    66
    67
    68
    ______________________________
     
    public boolean validate() {
    // un tableau : int[][] tableauFinal = new int[9][9]();
    // initialisation et actions sur le Sudoku
    // Vérifie les lignes et les colonnes 
     
    	for (int i = 0; i < tableauFinal.length; i++) {
     
    		BitSet bsRow = new BitSet(9);
     
    		BitSet bsColumn = new BitSet(9);
     
    			for (int j = 0; j < tableauFinal[i].length; j++) {
     
    				if (tableauFinal[i][j] == 0 || tableauFinal[j][i] == 0) continue;
     
    					if (bsRow.get(tableauFinal[i][j] - 1) || bsColumn.get(tableauFinal[j][i] - 1))
     
    					return false;
     
    						else {
     
    							bsRow.set(tableauFinal[i][j] - 1);
     
    							bsColumn.set(tableauFinal[j][i] - 1);
     
    							}
     
    						}
     
    					}
     
    // Vérifie les quadrans (3x3)
     
    	for (int rowOffset = 0; rowOffset < 9; rowOffset += 3) {
     
    		for (int columnOffset = 0; columnOffset < 9; columnOffset += 3) {
     
    			BitSet threeByThree = new BitSet(9);
     
    				for (int i = rowOffset; i < rowOffset + 3; i++) {
     
    					for (int j = columnOffset; j < columnOffset + 3; j++) {
     
    						if (tableauFinal[i][j] == 0) continue;
     
    							if (threeByThree.get(tableauFinal[i][j] - 1))
     
    								return false;
     
    							else
     
    							threeByThree.set(tableauFinal[i][j] - 1);
     
    							}
     
    						}  
     
    					}
     
    				}
     
    		return true;
     
    	}
     
    }

  11. #11
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Février 2017
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Finance

    Informations forums :
    Inscription : Février 2017
    Messages : 25
    Points : 8
    Points
    8
    Par défaut
    Certains appellent la classe ArrayList un tableau dynamique (ce que je pense être biaisé, déjà parce qu'on attribut un comportement à une implémentation interne dont on n'a normalement pas à soucier fonctionnellement). Pour diverses raisons (performance / mémoire) on choisit d'utiliser une implémentation à base de tableau, mais on manipule une List, point barre.
    >> Bien compris. Donc mon erreur aurait été de déterminer un tableau dont la table est fixe est lorsque j'aurais appelé la méthode setN, j'en aurais changé la taille sans en changer le contenu ... pas beaucoup de sens effectivement

    On te demande de remplacer le int par une instance de Case.
    Donc, là où tu as dans ta méthode creerPlacement, this.grille[x][y]=valeur;, tu vas avoir un appel de méthode de la classe Case à la place, sur l'instance représentant la case de coordonnées x,y.

    >> Je vais insérer quelque chose comme c = new Case() pour renvoyer à la classe Case.

    MERCI !!!!!

  12. #12
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Février 2017
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Finance

    Informations forums :
    Inscription : Février 2017
    Messages : 25
    Points : 8
    Points
    8
    Par défaut Pour la classe Case
    Re-Salut,


    Pour ma classe destinée à sauver le contenu d'une ces, je pensais à quelque chose du genre. Avis ou commentaire? Merci !

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class Case {
      private int x;
     private int y;
     
      public Case(int x, int y) {
        this.x = x;
        this.y = y;
       }
    }

  13. #13
    Rédacteur/Modérateur

    Avatar de bouye
    Homme Profil pro
    Information Technologies Specialist (Scientific Computing)
    Inscrit en
    Août 2005
    Messages
    6 838
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : Nouvelle-Calédonie

    Informations professionnelles :
    Activité : Information Technologies Specialist (Scientific Computing)
    Secteur : Agroalimentaire - Agriculture

    Informations forums :
    Inscription : Août 2005
    Messages : 6 838
    Points : 22 846
    Points
    22 846
    Billets dans le blog
    51
    Par défaut
    Le seul commentaire que je peux faire c'est qu'il faut utiliser la balise [CODE] (bouton # dans la barre de l’éditeur) lorsqu'on tape du code !
    Merci de penser au tag quand une réponse a été apportée à votre question. Aucune réponse ne sera donnée à des messages privés portant sur des questions d'ordre technique. Les forums sont là pour que vous y postiez publiquement vos problèmes.

    suivez mon blog sur Développez.

    Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the universe trying to produce bigger and better idiots. So far, the universe is winning. ~ Rich Cook

  14. #14
    Modérateur
    Avatar de joel.drigo
    Homme Profil pro
    Ingénieur R&D - Développeur Java
    Inscrit en
    Septembre 2009
    Messages
    12 430
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D - Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2009
    Messages : 12 430
    Points : 29 131
    Points
    29 131
    Billets dans le blog
    2
    Par défaut
    Citation Envoyé par jalkhar Voir le message

    Pour ma classe destinée à sauver le contenu d'une ces, je pensais à quelque chose du genre. Avis ou commentaire? Merci !
    Dans la grille int[][], chaque case sert à stocker le chiffre qu'on place dans cette case, et 0, une valeur spéciale qui signifie que la case est vide (sans chiffre). A ton avis, si on remplace la grille par un Case[][], que faut-il absolument stocker dans Case pour avoir l'équivalent de int[][] ?
    L'expression "ça marche pas" ne veut rien dire. Indiquez l'erreur, et/ou les comportements attendus et obtenus, et donnez un Exemple Complet Minimal qui permet de reproduire le problème.
    La plupart des réponses à vos questions sont déjà dans les FAQs ou les Tutoriels, ou peut-être dans une autre discussion : utilisez la recherche interne.
    Des questions sur Java : consultez le Forum Java. Des questions sur l'EDI Eclipse ou la plateforme Eclipse RCP : consultez le Forum Eclipse.
    Une question correctement posée et rédigée et vous aurez plus de chances de réponses adaptées et rapides.
    N'oubliez pas de mettre vos extraits de code entre balises CODE (Voir Mode d'emploi de l'éditeur de messages).
    Nouveau sur le forum ? Consultez Les Règles du Club.

  15. #15
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Février 2017
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Finance

    Informations forums :
    Inscription : Février 2017
    Messages : 25
    Points : 8
    Points
    8
    Par défaut
    Citation Envoyé par bouye Voir le message
    Le seul commentaire que je peux faire c'est qu'il faut utiliser la balise [CODE] (bouton # dans la barre de l’éditeur) lorsqu'on tape du code !

  16. #16
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Février 2017
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Finance

    Informations forums :
    Inscription : Février 2017
    Messages : 25
    Points : 8
    Points
    8
    Par défaut
    Citation Envoyé par bouye Voir le message
    Le seul commentaire que je peux faire c'est qu'il faut utiliser la balise [CODE] (bouton # dans la barre de l’éditeur) lorsqu'on tape du code !
    Merci pour le rappel. Je tiendrai compte de cette instruction.

  17. #17
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Février 2017
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Finance

    Informations forums :
    Inscription : Février 2017
    Messages : 25
    Points : 8
    Points
    8
    Par défaut
    Dans la grille int[][], chaque case sert à stocker le chiffre qu'on place dans cette case, et 0, une valeur spéciale qui signifie que la case est vide (sans chiffre). A ton avis, si on remplace la grille par un Case[][], que faut-il absolument stocker dans Case pour avoir l'équivalent de int[][] ?
    >> Il s'agit de stocker les valeurs de 1 à 9 contenues dans Grille et de les placer dans Case. Je pensais à un copyToArray mais je crois que cela revient à dupliquer grille [][]...

  18. #18
    Modérateur
    Avatar de joel.drigo
    Homme Profil pro
    Ingénieur R&D - Développeur Java
    Inscrit en
    Septembre 2009
    Messages
    12 430
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D - Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2009
    Messages : 12 430
    Points : 29 131
    Points
    29 131
    Billets dans le blog
    2
    Par défaut
    Non, non, tu n'as pas compris : ce qu'on te demande c'est d'utiliser une nouvelle classe Case (que tu auras écrite...) pour modéliser une case (d'où son nom) de la grille. La grille de sudoku est une matrice de cases, on peut la modéliser de 36 manières différentes, classiquement on pense à int[][], un tableau à 2 dimensions de int, parce que une grille de sudoku, c'est une grille (une matrice à 2 dimensions) de cases vides qu'on remplit de nombres, mais on peut la représenter différemment, un tableau à une dimensions de int (on accède à une case de coordonnées x,y par tableau[y*largeur+x]), voire un tableau d'octets, avec optimisation mémoire en fonction du plus grand nombre possible, un tableau de chaînes de caractères, ou une chaines de caractères..., une map avec pour clef un couple de coordonnées, et pour valeur une instance de Case, ou encore une image, en utilisant uniquement des concepts graphiques (les dessins des chiffres, des couleurs, etc), un arbre, etc.
    On te demande de représenter la notion de case de grille par une classe, donc chaque case de grille sera une instance de Case. Il ne faut pas faire une seconde grille qu'on passe son temps à copier, la première suffit largement. A partir du moment où toutes tes méthodes seront capables de travailler uniquement avec une instance de Case (et plus un int[][]), ça voudra dire que tu pourras faire des implémentations concrète où la grille n'est plus forcément un int[][] mais n'importe quel "ensemble" de Case.
    L'expression "ça marche pas" ne veut rien dire. Indiquez l'erreur, et/ou les comportements attendus et obtenus, et donnez un Exemple Complet Minimal qui permet de reproduire le problème.
    La plupart des réponses à vos questions sont déjà dans les FAQs ou les Tutoriels, ou peut-être dans une autre discussion : utilisez la recherche interne.
    Des questions sur Java : consultez le Forum Java. Des questions sur l'EDI Eclipse ou la plateforme Eclipse RCP : consultez le Forum Eclipse.
    Une question correctement posée et rédigée et vous aurez plus de chances de réponses adaptées et rapides.
    N'oubliez pas de mettre vos extraits de code entre balises CODE (Voir Mode d'emploi de l'éditeur de messages).
    Nouveau sur le forum ? Consultez Les Règles du Club.

  19. #19
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Février 2017
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Finance

    Informations forums :
    Inscription : Février 2017
    Messages : 25
    Points : 8
    Points
    8
    Par défaut
    Là je comprends l'utilité de Case. Donc c'est un peu comme si tu créais un système de coordonnées parallèles à int [][] dans lequel chaque case trouve sa propre référence.
    En bout de ligne tu peut instancier Case au lieu de la grille int [][].

    Bon et bien je pense que je vois le bout de ce travail grâce à ta patience. Je vais complier tout cela et voir ce que cela donne. J'aurai certainement une ou deux questions ciblées que je me permettrai de poser sur le forum.

    Merci pour le temps passé à répondre au néophyte que je suis

  20. #20
    Modérateur
    Avatar de joel.drigo
    Homme Profil pro
    Ingénieur R&D - Développeur Java
    Inscrit en
    Septembre 2009
    Messages
    12 430
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D - Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2009
    Messages : 12 430
    Points : 29 131
    Points
    29 131
    Billets dans le blog
    2
    Par défaut
    Ce n'est pas Case au lieu de int[][], c'est Case[][] au lieu de int[][].
    L'expression "ça marche pas" ne veut rien dire. Indiquez l'erreur, et/ou les comportements attendus et obtenus, et donnez un Exemple Complet Minimal qui permet de reproduire le problème.
    La plupart des réponses à vos questions sont déjà dans les FAQs ou les Tutoriels, ou peut-être dans une autre discussion : utilisez la recherche interne.
    Des questions sur Java : consultez le Forum Java. Des questions sur l'EDI Eclipse ou la plateforme Eclipse RCP : consultez le Forum Eclipse.
    Une question correctement posée et rédigée et vous aurez plus de chances de réponses adaptées et rapides.
    N'oubliez pas de mettre vos extraits de code entre balises CODE (Voir Mode d'emploi de l'éditeur de messages).
    Nouveau sur le forum ? Consultez Les Règles du Club.

Discussions similaires

  1. Java/DB : Besoin d'aide/conseils
    Par Askle dans le forum JDBC
    Réponses: 8
    Dernier message: 29/12/2009, 20h09
  2. Débutante, besoin de vos conseils
    Par rorette68 dans le forum Silverlight
    Réponses: 1
    Dernier message: 13/06/2009, 21h42
  3. Projet Java - besoin de conseils
    Par Machiavel dans le forum Java EE
    Réponses: 9
    Dernier message: 26/12/2006, 14h53
  4. Besoin de quelques conseils pour un script java
    Par poussin544 dans le forum Général JavaScript
    Réponses: 7
    Dernier message: 02/03/2006, 11h41

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo