Java mes propres classes

Version imprimable

Bonjour à tous, je viens d'étudier une leçon sur comment créer ses propres classes et, évidement, j'ai un exercice d'application qui m'est proposé.
Ce dernier consiste en un code semi complété et il m'est demandé de le finir.
Voici la consigne :

Vous devez compléter le programme en utilisant le mot clé this :

Écrivez le constructeur de cette classe.
Utilisez les méthodes accessors pour initialiser et obtenir les données de tous les champs privés de cette classe.
Écrivez une méthode main pour tester votre programme.

Le programme en question:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Sudoku {
 
    private int[][] tableaufinal;
    private int placements = 0;     // Placements représentent les emplacements possibles des chiffres de 1 à 9
    private int complexite = 0;     // Complexite :  1 (débutant), 2 (intermédiaire) et 3 (avancé)
    private String nom;             // Nom du joueur
    private int[][] grille;
    private int n;                 //nombre d'éléments dans le SUDOKU (un carré n*n, donc 3*3, 9*9, etc.)
 
    // constructeur de SUDOKU
    public Sudoku(String leNom, int n, int lesPlacements, int laComplexite) {
        // à compléter
        // ...
       initialisation();
    }
 
 
    public void initialisation () {
        // initialise tous les champs de la grille à 0
        // ...
    }
    // à compléter
 
}

et même si ce n'est pas grand chose, ce que j'ai fait pour l'instant:

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
public class Sudoku {
 
    private int[][] tableaufinal;
    private int placements = 0;     // Placements représentent les emplacements possibles des chiffres de 1 à 9
    private int complexite = 0;     // Complexite :  1 (débutant), 2 (intermédiaire) et 3 (avancé)
    private String nom;             // Nom du joueur
    private int[][] grille;
    private int n;                 //nombre d'éléments dans le SUDOKU (un carré n*n, donc 3*3, 9*9, etc.)
 
    // constructeur de SUDOKU
    public Sudoku(String leNom, int n, int lesPlacements, int laComplexite) {
        // à compléter
        // ...
    	nom = leNom;
    	placements = lesPlacements;
    	complexite = laComplexite;
 
       initialisation();
    }
 
 
    public void initialisation () {
        // initialise tous les champs de la grille à 0
        // ...
 
 
 
    }
    // à compléter
 
}

Je voulais savoir si vous pouviez m'aider à bien comprendre la structure de ce programme.

Donc je résume ce que j'ai compris :
Ici nous avons les variables qui sont initialisées.
je comprend pas trop pourquoi on a deux tableaux qui sont générés.

Code:

1
2
3
4
5
6
7
 
    private int[][] tableaufinal;
    private int placements = 0;     // Placements représentent les emplacements possibles des chiffres de 1 à 9
    private int complexite = 0;     // Complexite :  1 (débutant), 2 (intermédiaire) et 3 (avancé)
    private String nom;             // Nom du joueur
    private int[][] grille;
    private int n;    //nombre d'éléments dans le SUDOKU (un carré n*n, donc 3*3, 9*9, etc.)

Ensuite nous avons les constructeurs:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
public Sudoku(String leNom, int n, int lesPlacements, int laComplexite) {
        // à compléter
        // ...
    	nom = leNom;
    	placements = lesPlacements;
    	complexite = laComplexite;
 
       initialisation();
    }
 
 
    public void initialisation () { // ici dois-je mettre  les variables initialisées à zéro?
        // initialise tous les champs de la grille à 0
        // ...
 
 
 
    }

et finalement le dernier commentaire qui dit à compléter ligne 37.
Je suppose que c'est ici qu'ils veulent que je crée ma méthode main.

Merci par avance de votre aide.

Salut,

Citation:

Envoyé par while.dede

je comprend pas trop pourquoi on a deux tableaux qui sont générés.

Probablement la grille de sudoku cible (le sudoku terminé) et celle dans laquelle on joue.

Citation:

Envoyé par while.dede

Écrivez le constructeur de cette classe.
Utilisez les méthodes accessors pour initialiser et obtenir les données de tous les champs privés de cette classe.
Écrivez une méthode main pour tester votre programme.

...
Vous devez compléter le programme en utilisant le mot clé this :
Citation:
Envoyé par while.dede
Code:

1 2 3 4 5 6 7 8 9 10 11 // constructeur de SUDOKU public Sudoku(String leNom, int n, int lesPlacements, int laComplexite) { // à compléter // ... nom = leNom; placements = lesPlacements; complexite = laComplexite; initialisation(); }
Il manque des initialisations de variable :

n (occasion d'utiliser le this)
les tableaux (qu'on est obliger d'initialiser ici, car la dimension est passée en argument du constructeur (n)
Citation:
Envoyé par while.dede
Code:

1 2 3 4 5 6 7 8 public void initialisation () { // initialise tous les champs de la grille à 0 // ... } // à compléter }
initialise tous les champs de la grille à 0 = remplir de 0 le tableau grille (au moins).

Citation:

Envoyé par while.dede

et finalement le dernier commentaire qui dit à compléter ligne 37
Je suppose que c'est ici qu'ils veulent que je crée ma méthode main.

et finalement le dernier commentaire qui dit à compléter ligne 37 (ligne 22 dans le code que tu nous mis je suppose) :

Commence par :

Citation:

Envoyé par while.dede

Utilisez les méthodes accessors pour initialiser et obtenir les données de tous les champs privés de cette classe.

puis, en effet :

Citation:

Envoyé par while.dede

Écrivez une méthode main pour tester votre programme.

Sous-entendu, à priori, tester les "accessors" (accesseurs) que tu a écrits..

23/03/2015, 15h02
while.dede

Merci pour tout ces conseils, juste une autre question avant de me lancer, je dois avouer que je ne comprend pas trop comment fonctionne le "n" pour calculer le nombre d'éléments.
23/03/2015, 15h09
joel.drigo

Il n'y a pas de calcul, c'est juste un paramètre.

Si on veut une grille 3x3, on passe 3 :

Code:

new Sudoku("ploumploum 3x3", 3, ...)

Pour une grille 9x9, on passe 9 :

Code:

new Sudoku("ploumploum 9x9", 9, ...)

ensuite, les tableaux doivent être dimensionnés en fonction de n...

Moi, ce que je capte pas c'est plutôt cette variable placements :

Code:

private int placements = 0; // Placements représentent les emplacements possibles des chiffres de 1 à 9

J'aimerais bien avoir des exemples... parce que non seulement je ne vois pas à quoi ça sert au juste... et quel sens c'est censé avoir surtout...
23/03/2015, 16h29
while.dede

d'accord ok j'ai compris pour n.
Sinon pour la variable placement, je dois avouer que je ne suis pas sur, on ne m'a pas donné plus d'info sur ce code. Mais selon moi ça doit correspondre au système de résolution du sudoku, c'est à dire, sachant qu'il ne faut pas qu'il y ait plus d'une fois sur une ligne et une colonne le même chiffre, cette variable permettrait de savoir quel chiffre mettre en respectant cette règle.
23/03/2015, 16h42
joel.drigo
Citation:

Envoyé par while.dede

Mais selon moi ça doit correspondre au système de résolution du sudoku, c'est à dire, sachant qu'il ne faut pas qu'il y ait plus d'une fois sur une ligne et une colonne le même chiffre, cette variable permettrait de savoir quel chiffre mettre en respectant cette règle.
1. C'est une règle inhérente au sudoku, donc pas besoin de passer une valeur en paramètre
2. et puis cette valeur qui serait le placement de chiffres de 1 à 9 (dixit le commentaire sibyllin), en supposant qu'il s'agisse de la règle dont tu parles, ce serait quoi ?
  - Par exemple, si je passe 18429 en paramètre, ça fait quoi ? quel impact sur la position des nombres de 1 à 9 dans une grille de n×n ? Comment écrire le code qui doit l'interpréter cette valeur pour que le même chiffre ne soit pas 2 fois dans la même ligne ou colonne.
  - Ou, ne serait-ce que 0, ou 1, par exemple ? Ou 42 ?
23/03/2015, 16h48
while.dede

je suis en train de compléter le programme, concernant l'argument n que je dois utiliser pour le tableau je ne sais pas trop comment le formuler dans mon constructeur.
En fait je sais le faire pour une variable comme nom, complexité etc
Mais pour un tableau je patauge.
23/03/2015, 17h12
while.dede
Citation:
Envoyé par joel.drigo

C'est une règle inhérente au sudoku, donc pas besoin de passer une valeur en paramètre
et puis cette valeur qui serait le placement de chiffres de 1 à 9 (dixit le commentaire sibyllin), en supposant qu'il s'agisse de la règle dont tu parles, ce serait quoi ?

Par exemple, si je passe 18429 en paramètre, ça fait quoi ? quel impact sur la position des nombres de 1 à 9 dans une grille de n×n ? Comment écrire le code qui doit l'interpréter cette valeur pour que le même chiffre ne soit pas 2 fois dans la même ligne ou colonne.
Ou, ne serait-ce que 0, ou 1, par exemple ? Ou 42 ?
Honnêtement je n'en sais rien, c'est vrai qu'au départ je n'y avait pas prêté attention, mais depuis que tu me l'as fait remarqué je vois pas trop à quoi elle peut servir. J'ai cherché dans mon cours, en espérant trouver des exemples utilisant la même variable, mais rien du tout.
La seul explication que j'ai et qui de plus n'est pas claire, c'est celle en commentaire " Placements représentent les emplacements possibles des chiffres de 1 à 9"

Bah, tout simplement :

Code:

1
2
3
this.n = n; // affectation du paramètre n à la variable de classe n 
grille = new int[n][n]; // déclaration du tableau grille pour qu'il fasse n lignes de n colonnes
tableaufinal = new int[n][n]; // idem pour tableauFinal

23/03/2015, 17h30
while.dede

Bon d'accord c’était tout simple, je pensais quelque chose de plus compliqué, merci.
Concernant la variable placement, je viens d'envoyer un mail au tuteur qui est censé être à notre disposition en cas de problèmes, en lui posant la question de comment cette variable est censée agir. Reste plus qu'à attendre la réponse.
23/03/2015, 17h52
while.dede

pour initialiser tout les champs de la grille il me suffit de faire ça :

Code:

int grille [][] = {{0,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0,0}};

ou faut il ajouter autre chose?
23/03/2015, 18h15
joel.drigo
Argh ! Non, surtout pas. La taille du tableau est n : avec ton code, tu fixes une taille de tableau. En plus, là, tu mets 2 lignes de 8 zéros :koi:
1. première solution : parcourir les éléments du tableaux et mettre 0.Donc parcourir les lignes avec un for, puis dans chaque ligne parcourir les colonnes avec un for imbriqué dans le premier
  Code:
  
  1 2 3 4 5 for(int i=0; i<grille.length; i++) { for(int j=0; j<grille[i].length; j++) { grillle[i][j]=0; } }
2. Utiliser la méthode Arrays.fill(). Problème cette méthode ne sait traiter que les tableaux à une dimension. Solution : parcourir les lignes, et appeler cette méthode sur chaque ligne.
  Code:
  
  1 2 3 for(int[] ligne : grille ) { Arrays.fill(ligne, 0); }
3. Par défaut, un tableau contient forcement des 0. On pourrait ne rien faire. Cependant, la méthode pourrait peut-être être appelée après qu'on est mis autre chose que des 0 dans le tableau (par exemple, après avoir joué). Et puis, on te demande de la faire, ce n'est pas pour rien, à priori, ne serait-ce que pour voir si tu sais le faire...

ok j'ai compris, merci de m'avoir expliqué les différentes méthodes, celle qui me semble la plus simple et qui évite d'utiliser Array.fill() pour chaque ligne est la première.
Et voilà en appliquant tes conseils :
bon, il me reste juste à ajouter les accesseurs et la méthode main , je m'en occupe de suite.

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
public class Sudoku {
 
    private int[][] tableaufinal;
    private int placements = 0;     // Placements représentent les emplacements possibles des chiffres de 1 à 9
    private int complexite = 0;     // Complexite :  1 (débutant), 2 (intermédiaire) et 3 (avancé)
    private String nom;             // Nom du joueur
    private int[][] grille;
    private int n;                 //nombre d'éléments dans le SUDOKU (un carré n*n, donc 3*3, 9*9, etc.)
 
    // constructeur de SUDOKU
    public Sudoku(String leNom, int n, int lesPlacements, int laComplexite) {
        // à compléter
        // ...
    	this.n = n;
    	grille = new int[n][n];
    	tableaufinal = new int[n][n];
    	nom = leNom;
    	placements = lesPlacements;
    	complexite = laComplexite;
 
       initialisation();
    }
 
 
    public void initialisation () {
        // initialise tous les champs de la grille à 0
        // ...
    	for(int i=0; i<grille.length; i++) {
    	    for(int j=0; j<grille[i].length; j++) {
    	          grille[i][j]=0;
    	    }
    	}
 
    }
    // à compléter
 
}

23/03/2015, 19h01
joel.drigo

C'est un paramètre du constructeur public Sudoku(String leNom, int n, int lesPlacements, int laComplexite) {.

Après qui l'entre, c'est le sujet qui parle de ça. Moi, j'en sais rien. C'est pas moi qui est fait le sujet. Mais on peut le supposer oui. Cela dit, on pourrait tout aussi bien imaginer un programme qui génère automatiquement des grilles de sudoku en faisant varier de n de 3 à 9, par exemple. A la limite, ce n'est pas le problème de la classe sudoku : elle à la taille de la grille en paramètre, c'est tout.
23/03/2015, 19h05
while.dede

Ok merci pour l'explication concernant le n, c’était juste histoire d’être sur.
23/03/2015, 19h07
while.dede
Une autre petite question, concernant les accesseurs pour les deux tableaux.
Je les ai formulés comme ceci:
Code:

1 2 3 4 5 6 7 8 public int getTableau() { return tableaufinal; } public int getGrille() { return grille; }
Mais apparemment il y a une erreur, il ne pourrait pas convertir un int vers en autre int.
Que dois-je modifier pour parer à cela?
23/03/2015, 19h19
joel.drigo

regarde la déclaration de grille et tableaufinal ! On a dit que c'était des tableaux de int, pas des int...

D'accord, là ça me semble correct:

Code:

1
2
3
4
5
6
7
8
 public int getTableau(int i, int j)
    {
    	return tableaufinal [i][j];
    }
    public int getGrille(int i, int j)
    {
    	return grille [i][j];
    }

Merci pour tout.