Débutant en java - besoin d'un conseil

Version imprimable

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:

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

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:

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

11/02/2017, 20h39
jalkhar

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,

Citation:

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:

1 2 3 public abstract class AbstractGrid<T> { public abstract int size(); }
Code:

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:

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

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:

1 2 3 4 5 if ( grille instanceof ImplementationConcrete1 ) { ((ImplementationConcrete1)grille).methodeSpecifique1(); } else if ( grille instanceof ImplementationConcrete2 ) { ((ImplementationConcrete2)grille).methodeSpecifique2(); }
Mais

Code:

grille.methodeGenerique();

Et on pourra avoir :
Code:

1 2 3 public abstract class AbstractExemple { public abstract void methodeGenerique(); }
Code:

1 2 3 public abstract class AbstractExemple { public abstract void methodeGenerique(); }
Code:

1 2 3 4 5 6 7 8 public class ImplementationConcrete1 extends AbstractExemple { public void methodeGenerique() { methodeSpecifique1(); } public void methodeSpecifique1() { // ... } }
Code:

1 2 3 4 5 6 7 8 public class ImplementationConcrete2 extends AbstractExemple { public void methodeGenerique() { methodeSpecifique2(); } public void methodeSpecifique2() { // ... } }

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:

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:

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:

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

13/02/2017, 04h43
bouye

Merci d'utiliser la balise :tagcode: quand tu tape du code.

Salut,

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

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

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.

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).
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.
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:

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

14/02/2017, 04h56
jalkhar

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 :mouarf:

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,

Citation:

Envoyé par jalkhar

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:

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

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

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:

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

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

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 :
une écriture un peu compliqué et fastidieuse de récupération de la fin :

Code:

Placement dernier = placements.get(placements.size()-1);

En revanche, tu peux simplifier dans ton code l'écriture de la suppression, en écrivant directement :

Code:

Placement dernier = placements.remove(placements.size()-1);

une écriture plus concise mais une exécution moins performante, en ajoutant non pas à la fin mais au début

Code:

placements.add(0, placement);

et pour la suppression

Code:

Placement placement = placements.remove(0);
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:

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

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.

Citation:

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:

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

15/02/2017, 03h56
jalkhar

Citation:

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 :ptdr:

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 !!!!!
15/02/2017, 04h02
jalkhar

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:

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; } }
15/02/2017, 06h01
bouye

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 ! :sm: :fessee:
15/02/2017, 10h13
joel.drigo

Citation:

Envoyé par jalkhar

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[][] ?
15/02/2017, 13h42
jalkhar

Citation:

Envoyé par bouye

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 ! :sm: :fessee:
15/02/2017, 13h43
jalkhar

Citation:

Envoyé par bouye

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 ! :sm: :fessee:

Merci pour le rappel. Je tiendrai compte de cette instruction.
15/02/2017, 13h46
jalkhar

Citation:

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 [][]...
15/02/2017, 16h59
joel.drigo

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.
16/02/2017, 04h25
jalkhar

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 :) :calim2:
16/02/2017, 10h36
joel.drigo

Ce n'est pas Case au lieu de int[][], c'est Case[][] au lieu de int[][].
16/02/2017, 14h33
jalkhar

Erreur de compilation

J'ai une seule erreur lors de la compilation.

Le message d'erreur est "cannot find symbol" et porte sur la ligne de code suivante qui se trouve dans ma classe principale

>>> Sudoku9x9 jeu1 = new Sudoku9x9("Joueur1", 9, 10, 1); // Instanciation de l'objet jeu1 dans la classe Sudoku9x9

Pouvez-vous m'aider en me disant pourquoi l'objet n'est pas reconnu?

Merci
16/02/2017, 15h35
joel.drigo

C'est difficile sans avoir le code, et/ou, le message complet. "Cannot resolve symbol" quel symbol ? Sudoku9x9 ? Soit la classe n'existe pas (attention à l'importance de la casse), soit la classe n'est pas dans le même package (que celle qui à l'instruction qui fait le new) et l'import est manquant.