Débutant en java - besoin d'un conseil

**jalkhar** · 11/02/2017, 16h26

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

**joel.drigo** · 11/02/2017, 17h26

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);
}

**jalkhar** · 11/02/2017, 19h39

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,

**joel.drigo** · 12/02/2017, 11h37

Envoyé par jalkhar

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.

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.
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;
      }
  }
}

Envoyé par jalkhar

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() {
           // ...
    }
}

**jalkhar** · 12/02/2017, 15h44

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;
 
	}
 
*************************************************

**bouye** · 13/02/2017, 03h43

Merci d'utiliser la balise

quand tu tape du code.

Débutant en java - besoin d'un conseil

avec Java

Vue hybride

Discussions similaires

Partager

Partager