Discussion :

[Aline64]

Bonjour,
Je suis nouvelle ici car en formation depuis octobre pour une reconversion, j'ai donc commencé les cours de Java. Pour valider ce semestre, nous devons réaliser un jeu d'échecs.
Les premières consignes sont :
1. Créer une classe principale Echecs dans laquelle vous devez initialiser un tableau à 2 dimensions (8 x 8 ) nommé Echiquier . Ce tableau représente les cases de l’ échiquier : à un instant t , une case est soit libre , soit occupé par une pièce . Chaque pièce sera référencée par un code sur 2 constitué du type de la pièce (T=Tour , F=Fou , P=Pion, Q=Reine, K=Roi, C=Cavalier ) + le code joueur (B pour les blancs, N pour les noirs)
2. Créer et implémenter une méthode initialiser qui ,étant donné l’échiquier, positionne les pièces selon la disposition conventionnelle des pièces des blancs et des noirs en début de partie , et retourne l’échiquier ainsi initialisé .
3. Créer et implémenter une méthode afficher qui , étant donné l’échiquier, affiche à la console l’échiquier avec les pièces de la manière la plus lisible possible .
4.Testez les méthodes afficher et initialiser dans la méthode principale de la classe Echecs .

Le code que j'ai créée :

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
package echecs;
import java.util.*;
 
public class Echecs {
 
	public static void main (String [] arg) {
	String Echiquier[][];
	Echiquier = new String [8][8];
 
 
	initialiser(Echiquier);
	afficher(Echiquier);
 
 
	} // fin main
 
	public static void initialiser (String[][] tableau)
	{
		String [][] echiquier = {
				{"TN","CN","FN","KN","QN","FN","CN","TN"},
				{"PN", "PN", "PN","PN", "PN", "PN", "PN", "PN"},
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{"PB", "PB", "PB", "PB", "PB", "PB", "PB", "PB"},
				{"TB","CB","FB","KB","QB","FB","CB","TB"}
		};
 
	} // fin méthode position initiale des pièces
 
	public static void afficher (String[][] tableau)
	{
		for (int i=0; i<tableau.length ; i++)
		{
 
			for (int j=0;j<tableau[i].length; j++)
			{
				System.out.print(tableau[i][j]+" , ");
			}
			System.out.println(" ");
		}
 
	} // fin méthode afficher
 
 
} // fin class echecs

Malheureusement, je ne parviens pas à "remplacer" le tableau vide du main par celui de la méthode initialiser, je suppose qu'il faut utiliser "new" mais je ne connais pas la syntaxe pour les String. Pourriez-vous m'aider s'il vous plait ?
Je vous remercie.
(Si le sujet pouvait rester ouvert un peu parce que je sens que j'aurais de nouveau besoin d'aide pour le reste du projet...)
Merci beaucoup

[yildiz-online]

Bonjour quelques remarques generales avant de commencer:

1)Il est souvent bon de preferer les imports complets plutot que d'utiliser import package.* pour eviter les risques de collision sur plusieurs classes avec le meme nom aparaissant dans des packages differents.
2)Les conventions de nommage standard java sont pour les variable le camel case debutant par une minuscule, mieux vaut s'en tenir aux standard pour eviter de pendre de mauvaises habitudes. (https://www.oracle.com/java/technolo...nventions.html)

Pour le probleme en lui meme, il ne faut pas recreer un nouveau tableau mais modifier son contenu a l'indice voulu, donc echiquer[0][0] = "TN", echiquer[0][1]="CN" etc...
Mais il serait preferable de creer l'echiquier et l'initialiser dans la fonction elle meme plutot que de le promener pour eviter les effets de bords possible, en utilisant cette signature de fonction: private static String[][] initialiser();

Ce cours est tres bien pour debuter: https://www.jmdoudoux.fr/java/dej/chap-syntaxe.htm

[Aline64]

Je te remercie pour ces informations.

1) Il est souvent bon de préférer les imports complets plutôt que d'utiliser import package.* pour éviter les risques de collision sur plusieurs classes avec le même nom apparaissant dans des packages différents.

C'est noté, merci pour l'information

2)Les conventions de nommage standard java sont pour les variable le camel case débutant par une minuscule, mieux vaut s'en tenir aux standard pour éviter de pendre de mauvaises habitudes.

Comme expliqué, je suis les consignes données à savoir "initialiser l'échiquier à 2 dimensions (8 x 8 ) nommé Echiquier." avec une majuscule...

Pour le problème en lui même, il ne faut pas recréer un nouveau tableau mais modifier son contenu a l'indice voulu, donc echiquer[0][0] = "TN", echiquer[0][1]="CN" etc...
Mais il serait préférable de créer l’échiquier et l'initialiser dans la fonction elle même plutôt que de le promener pour éviter les effets de bords possible, en utilisant cette signature de fonction: private static String[][] initialiser();

Tu suggères de ne pas créer l'échiquier dans le Main ? pardon pour les questions, je suis vraiment débutante.

Merci pour le lien, je vais regarder ça attentivement.

[PhilippeGibault]

Bonjour,

Quand on a un problème compliqué, comme c'est un peu le cas ici, il faut le découper en plusieurs sous problèmes simple et compréhensible.
C'est le principe du rasoir d'Ockham.

https://fr.wikipedia.org/wiki/Rasoir_d%27Ockham

Voici un début possible (largement améliorable).

Pour commencer, je n'ai pas n'importe quoi comme pièce.
Je devrais donc lister les pièces.
L'enum est parfait:
https://www.baeldung.com/a-guide-to-java-enums

Soit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
public enum TypePiece{
  ROI,DAME,TOUR,CAVALIER,FOU,PION
}

On a selon le même principe deux couleur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
public enum Couleur{
  BLANC,NOIR
}

On peut donc définir la pièce, par record dans les nouvelles versions de Java:
https://www.jmdoudoux.fr/java/dej/chap-records.htm
https://www.baeldung.com/java-record-keyword

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
public record Piece(TypePiece type, Couleur couleur) {}

De fait on peut passer à l'échiquier (problème suivant).

La version la plus simple (voir simpliste) est un tableau 8*8 qui donne l'état de l'échiquier:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
Optional<Piece>[][]

Notez l'utilisation d'un Optional, car il se peut qu'il n'y ait pas de pièce sur une case.
https://www.baeldung.com/java-optional

Du coup, comme l'a expliqué @yildiz-online, le déplacement d'une pièce est l'échange de deux position du tableau (et la prise étant le remplacement pas Optional.empty()).

Si on doit dessiner l'échiquier, c'est un autre problème, et on se basera sur le tableau réel.

On peut aussi complexifier la modélisation de l'échiquier (couleur de la case, coordonnées...) mais j'ai préféré resté simpliste.

[Aline64]

Merci pour toutes ces informations.
Je pensais que mettre les consignes aiderait à comprendre ce qu'il m'est demandé de faire.
Vos réponses sont très complètes, vont bien au-delà de ce que je sais faire, et ce qui est demandé, il me semble. Par exemple, je ne connais pas du tout la fonction enum, qui viendra peut être après dans le cours et répondra aux autres consignes.

[PhilippeGibault]

Bon, il faut effectivement peut-être aller plus loin.

Pour rappel, un échiquier, ça ressemble à ça:
https://fr.wikipedia.org/wiki/%C3%89chiquier

Un échiquier, ça a des cases, que pour la suite, on va contractualiser:

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
 
public interface Case(){
 
  Optional<Piece> getPiece();
 
  void deplacePiece(Optional<Piece> nouvellePiece);
 
  void retirePiece();
 
  String abscisse();
 
  Integer ordonnee();
 
  Couleur couleur();
}

Il s'agit de ce que verra l'utilisateur. Un utilisateur sait ce que ça fait, mais il ne doit surtout pas savoir comment ça fonctionne. Il ne voit que un contrat, soit, en langage UML, ce que l'on appelle une interface.

On va donc donner une implémentation:

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
 
public class CaseImpl() implements Case{
 
  private final String abscisse;
  private final Integer ordonnee;
  private final Couleur couleur;
 
  private Optional<Piece> pieceSurCase;
 
 
  public CaseImpl(Optional<Piece> pieceSurCase,String abscisse,Integer ordonnee,Couleur couleur){
    this.pieceSurCase = pieceSurCase;
    this.abscisse = abscisse;
    this.ordonnee = ordonnee;
    this.couleur = couleur;
  }
 
  @Override
  public Optional<Piece> getPiece(){
    return pieceSurCase;
  }
 
  @Override
  public void deplacePiece(Optional<Piece> nouvellePiece){
    pieceSurCase = nouvellePiece;
  }
 
  @Override
  public void retirePiece(){
   pieceSurCase = Optional.empty();
  }
 
  @Override
  public String abscisse(){
    return abscisse;
  }
 
  @Override
  public Integer ordonnee(){
    return ordonnee;
  }
 
 @Override
 public Couleur couleur(){
   return couleur;
 }
}

On peut donc contractualiser l'échiquier.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
public interface Echiquier{
  void initialise();
 
  List<Case> afficher();
}

Notez que j'ai décidé contrairement sans doute à l'énoncé de lister les cases. Pour le voir en ayant une compréhension humaine, il faut en plus surcharger toString (correctement surchargé pour un record, à redéfinir pour une classe):
https://www.baeldung.com/java-tostring

Soit (là, ça devient chiant, lourd et fastidieux):

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
 
public class EchiquierImpl implements Echiquier{
  private final List<Case> cases;
 
  public Echiquier(){
    cases = new ArrayList<>();
  }
 
  @Override
  public void initialise(){
   //Ici code chiant
   cases.clear()//On néinitialise
 
   //Ligne 1(Blanc)
   cases.add(new Case(new Piece(TypePiece.TOUR,Couleur.BLANC),"a",1,Couleur.NOIR));
   cases.add(new Case(new Piece(TypePiece.CAVALIER,Couleur.BLANC),"b",1,Couleur.BLANC));
   cases.add(new Case(new Piece(TypePiece.FOU,Couleur.BLANC),"c",1,Couleur.NOIR)); 
   //Compléter suite ligne 1
 
   //Ligne 2(Blanc)
   cases.add(new Case(new Piece(TypePiece.PION,Couleur.BLANC),"a",2,Couleur.BLANC));
   cases.add(new Case(new Piece(TypePiece.PION,Couleur.BLANC),"b",2,Couleur.NOIR));
   //Compléter suite ligne 2
 
   //Ligne 3
   cases.add(new Case(Optional.empty(),"a",1,Couleur.NOIR));
   cases.add(new Case(Optional.empty(),"b",1,Couleur.BLANC));
   //Faire la suite
  }
 
  @Override
  public List<Case> afficher(){
    return cases;
  }
}

[yildiz-online]

Oui je suggere de ne pas creer (le terme est instancier quand on utilise un new) le tableau dans la fonction main, mais bien dans la fonction initialiser, ceci pour plusieurs raisons:

1) le main devrait etre aussi simple que possible et ne contenir que les appels vers les fonctions metiers, afin de preserver la lisibilite du code
2) les new sont un facteur bloquant en java(que ce soit au niveau du code ou semantique), tu le verra lorsque le paradigme oriente objet sera aborde, mais vu qu'ils sont lies aux constructeurs de classes, il posent vite des limitation qui sont levee en delegant la creation vers des fonctions dediees, bien que dans ce cas, l'interet soit limite vu que c'est un simple tableau, mais si ton code evolue vers de l'objet tu auras un meilleure base de travail.
3) et surtout passer des objets mutable (dont l'etat interne peut etre modifie, c'est le cas des tableaux) en parametre d'une fonction est un risque eleve d'effet de bord, qui augmente en fonction de la complexite et du nombre de fonctions, il est des lors souvent preferable de soit passer un objet non modifiable et de creer un nouvelle version modifiee dans la fonction pour ensuite la retourner, ca evite les mauvaises surprise lorsque plusieurs processus travaillent "en meme temps" sur un objet commun, ou tout simplement si l'objet n'etait pas sense etre modifie, c'est donc une bonne habitude a prendre.

Il y a dans cet exercice de nombreuses entorses a la programmation (ce qui a suscite la reaction de Phillipe je suppose), ce qui est normal dans un but didactique afin d'apprendre les bases, mais faire l'impasse sur les conventions de nommage n'apporte rien en terme d'apprentissage, au contraire, tu pourrais remonter cette info vers ton professeur (avec la reference vers le site d'Oracle), pas besoin de le confronter, juste remonter l'info et voir ce qu'il en dit.

[Aline64]

Merci beaucoup pour vos différentes solutions et votre aide. J'y vois plus clair et je vais continuer à travailler sur ce projet.

[Pandi_Panda02]

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
 
public class Echecs {
 
	public static void main (String [] arg) {
	String Echiquier[][];
	Echiquier = new String [8][8];
 
 
	initialiser(Echiquier);
	afficher(Echiquier);
 
 
	} // fin main
 
	public static void initialiser (String[][] tableau)
	{
		String [][] echiquier = {
				{"TN","CN","FN","KN","QN","FN","CN","TN"},
				{"PN", "PN", "PN","PN", "PN", "PN", "PN", "PN"},
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{"PB", "PB", "PB", "PB", "PB", "PB", "PB", "PB"},
				{"TB","CB","FB","KB","QB","FB","CB","TB"}
		};
 
	} // fin méthode position initiale des pièces

Tu mets en paramètre ton tableau de String dans la méthode initialiser en paramètre.
Mais dans l'implémentation de la méthode, tu n'y touche pas et en crée un autre.
Donc en effet, ton échiquier ne change 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
public static void initialiser (String[][] tableau)
	{
		String [][] echiquier = {
				{"TN","CN","FN","KN","QN","FN","CN","TN"},
				{"PN", "PN", "PN","PN", "PN", "PN", "PN", "PN"},
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{"PB", "PB", "PB", "PB", "PB", "PB", "PB", "PB"},
				{"TB","CB","FB","KB","QB","FB","CB","TB"}
		};
 
	} // fin méthode position initiale des pièces

tableau est passé en paramètres, mais tu n'y touche a aucun moment dans la méthode.
Donc soit tu enlève le paramètre, vu qu'il ne sert à rien en l'état.
Soit tu change echiquier par tableau.