Problème d'accès méthodes classes/interface

Version imprimable

25/04/2017, 18h06
St-42-FCM-57

Problème d'accès méthodes classes/interface

Bonjour,

je suis entrain d'essayer d'implémenter un monopoly, seulement j'ai un petit soucis.
Je vous explique brièvement mon architecture :
- Interface Case
- Diverses classes qui implémentent Case
- classe Plateau, qui contient un ArrayList de Case

J'ai numéroté toutes mes cases. Mais je souhaiterais faire un toString du contenu de Plateau, dans l'ordre de la numérotation. Dans l'interface Case il y a une méthode getNumeroCase(). Seulement, apparemment je n'y ai pas accès dans la classe Plateau, et je ne peux donc pas trier mes différentes cases du plateau.

Sauriez-vous d'où vient le problème ?

Merci, et bonne soirée !

Salut,

Tu peux nous montrer le code ?

Normalement, de ce que tu décris, on imagine que dans plateau tu as un attribut listeDeCases :

Code:

1
2
3
4
5
6
7
public class Plateau {
 
    private List<Case> list = new ArrayList<>();
 
 
 
}

Dans ce cadre, il n'y a aucun souci pour accèder aux méthodes de l'interface Case :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Plateau {
 
    private List<Case> list = new ArrayList<>();
 
    public String toString() {
 
           // affiche les cases dans l'ordre des numéro de case, séparées par des virgules
           return list.stream().sorted(Comparator.comparing(Case::getNumeroCase)).map(Case::toString).collect(Collectors.joining(", "));
 
 
    }
 
    // exemple qui retourne le numéro de case de la case à l'index spécifié en argument
    public int getPosition(int caseIndex) {
           return list.get(caseIndex).getNumeroCase();
    }
 
}

Bonjour,

Oui, bien sûr, le voici :

Code:

1
2
3
4
5
6
7
 
public interface Case {
	String getNom();
	String getType();
	int getNumeroCase();
 
}

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
 
package plateau;
import cases.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
 
public class Plateau {
	private String nom;
	private ArrayList<Case> lesCases = new ArrayList<Case>();
 
	public Plateau(String nom) {
		super();
		this.nom = nom;
	}
 
	public String getNom() {
		return nom;
	}
 
	public void setNom(String nom) {
		this.nom = nom;
	}
 
	public int size() {
		return lesCases.size();
	}
 
	public Case get(int index) {
		return lesCases.get(index);
	}
 
	/*public void trier(ArrayList<Case> lesCases){
		int i, j, temp;
		for(i=0; i<lesCases.size()-1;i++){
			for(j=i+1;j<lesCases.size();j++)
			{
				if(lesCases.getNumeroCase(i)>lesCases.get(j))
				{
					temp=lesCases.get(i);
					lesCases.get(i)=lesCases.get(j);
					lesCases.get(j)=temp;
				}
			}
		}
	}*/ // C'est donc cette partie qui ne fonctionne pas. J'avais pensé à faire un tri avec 2 boucles.
 
 
 
	public boolean add(Case e) {
		return lesCases.add(e);
	}
 
	@Override
	public String toString() {
		return "Plateau [nom = " + nom + ", \n lesCases = " + lesCases + "";
	}
}

25/04/2017, 18h47
joel.drigo

Ton souci est là :

Code:

lesCases.getNumeroCase(i)

lesCases est du type List<Case>, pas Case. La méthode getNumeroCase() n'existe pas dans la classe List. C'est lesCases.get(i).getNumeroCase();.

En revanche, à moins qu'il ne s'agisse d'un exercice où tu dois implémenter toi-même un algorithme de tri, ne t'embêtes pas à chercher à implémenter un tri.
Pour trier la liste par numéro de case :

Code:

Collections.sort( list, Comparator.comparing(Case::getNumeroCase) );
25/04/2017, 19h00
St-42-FCM-57
Je ne comprends pas trop.
Il faut que je crée une nouvelle méthode où je rentre cette ligne ?
Code:

1 2 Collections.sort( lesCases, Comparator.comparing(Case::getNumeroCase) );
Non, je ne dois pas forcement écrire un algorithme de tri, c'était juste plus logique pour moi...

là tu as fait une méthode pour trier :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public void trier(ArrayList<Case> lesCases){ int i, j, temp; for(i=0; i<lesCases.size()-1;i++){ for(j=i+1;j<lesCases.size();j++) { if(lesCases.getNumeroCase(i)>lesCases.get(j)) { temp=lesCases.get(i); lesCases.get(i)=lesCases.get(j); lesCases.get(j)=temp; } } } }*/ // C'est donc cette partie qui ne fonctionne pas. J'avais pensé à faire un tri avec 2 boucles.
Et bien au lieu d'essayer d'écrire ton algorithme, et bien, tu fais simplement :
Code:

1 2 3 4 5 public void trier(ArrayList<Case> lesCases){ Collections.sort( lesCases, Comparator.comparing(Case::getNumeroCase) ); }
Tout simplement.

Sinon, je ne vois pas trop de quoi tu parles quand tu dis que c'est plus logique :koi: Si le but est de manipuler les listes, tout ça, ou de travailler un algorithme de tri, ok. Si c'est juste pour réinventer la roue pour le plaisir, alors c'est une perte de temps, et des risques de bugs, inutles.

if(lesCases.getNumeroCase(i)>lesCases.get(j))je n'avais pas même pas regarder l'expression à droite du > : lesCases.get(j) est du type Case ! Tu ne peux pas :

comparer des instances de Case par <
encore moins comparer un Case avec un int
sans parler de ce que j'ai déjà dit sur le fait que la classe de lesCases n'a pas de méthode getNumeroCase(int)

Pour comparer les numéro des cases il faut écrire if(lesCases.get(i).getNumeroCase()>lesCases.get(j).getNumeroCase()).

Au passage, c'est toujours mieux de toujours utiliser la classe ou l'interface la plus général, parce que ça ouvre plus ton code aux évolutions.

quand tu écris :

Code:

public void methode(ArrayList<Case> cases)

tu écris une méthode qui ne s'appliquent qu'aux ArrayList.

quand tu écris :

Code:

public void methode(List<Case> cases)

tu écris une méthode qui s'appliquent à toutes les List, aux ArrayList, mais aussi aux LinkedList ou autre... Si tu modifies l'implémentation concrête un jour, pas besoin de tout modifier partout.

A moins d'avoir besoin d'appeler des méthodes spécifiques à la classe concrête, il vaut mieux typer par l'interface, et encore. On pourait très bien écrire :
Code:

1 2 3 4 5 6 7 8 9 10 public static void remplir(List<Machin> list, int n) { for(int i=0; i<n; i++) { list.add(new Machin(/*... c juste pour l'exemple ...*/)); } if ( list instanceof ArrayList<?>) { ((ArrayList<?>)list).trimToSize(); // Traitement spécifique avec une méthode spécifique de ArrayList } }

25/04/2017, 20h09
St-42-FCM-57
J'ai essayé de copier ce code :
Code:

1 2 3 4 5 6 public void trier(ArrayList<Case> lesCases){ Collections.sort( lesCases, Comparator.comparing(Case::getNumeroCase) ); }
mais il ne veut pas le prendre, comparator et case::getNumeroCase sont soulignés en rouge. Comment ça se fait ? Il faut que je crée une méthode Comparator, où c'est un méthode propre à java ?

EDIT :
J'avais un problème de JRE apparemment, ca marche maintenant !

Seulement est-ce que je peux appeler trier dans mon main, ou faut-il l'appeler forcément dans Plateau ?

Pour le moment j'ai fait ça, dans Plateau :
Code:

1 2 3 4 5 public String toString() { trier(lesCases); return "Plateau [nom = " + nom + ", \n lesCases = " + lesCases + ""; }
Seulement, il me semble qu'en faisant ça, ma list n'est triée que pour le toString .
Code:

1 2 lesCases.get(i).getNumeroCase()
--> comment sait on dans quel ordre doit-on mettre les instructions ?

Merci pour de m'avoir parlé de la façon générale, je n'étais pas au courant, c'est bon à savoir.
Je m'excuse si mes questions sont un peu basiques, mais je n'ai jamais vraiment pratiqué de java auparavant, entre les cours et la pratique, il y a un monde... :D

Citation:

Envoyé par St-42-FCM-57

mais il ne veut pas le prendre, comparator et case::getNumeroCase sont soulignés en rouge. Comment ça se fait ? Il faut que je crée une méthode Comparator, où c'est un méthode propre à java ?

Comme tu t'en es rendu compte, cette syntaxe n'existe que en Java 8.

Citation:

Envoyé par St-42-FCM-57

Seulement est-ce que je peux appeler trier dans mon main, ou faut-il l'appeler forcément dans Plateau ?

La méthode trier() est une méthode public de Plateau, donc tu peux l'appeler dans n'importe quelle classe qui a une référence sur une instance de plateau :
Code:

1 2 3 Plateau plateau = new Plateau(...) plateau.trier(...)
Ce code peut être appelé n'importe où.

Seulement, il y a un soucis avec ta méthode : elle prend un paramètre, or ce paramètre, pour que c'est un sens, il faut que cela soit l'attribut listeCases de l'instance de Plateau, attribut privé, donc inacessible de l'extérieur de la classe.

En fait, on devrait avoir l'un de ces cas (ce n'est pas exhaustif) :

(Je n'ai mis que ce qui concerne la question et supprimer tout le reste de ta classe pour que ça soit plus clair)
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 public class Plateau { private List<Case> lesCases = new ArrayList<Case>(); // cette méthode trie la liste de cases private void trier(){ Collections.sort( lesCases, Comparator.comparing(Case::getNumeroCase) ); } // on ajoute une nouvelle case, on s'assure que la liste reste triée public boolean add(Case e) { if ( lesCases.add(e) ) { trier(); return true; } else { return false; } } @Override public String toString() { return "Plateau [nom = " + nom + ", \n lesCases = " + lesCases + ""; } }
La liste est toujours triée, quand on l'affiche elle est affichée triée
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 Plateau { private List<Case> lesCases = new ArrayList<Case>(); // cette méthode trie la liste de cases private List<Case> trier(){ List<Case> copie = new ArrayList<Case>(lesCases); Collections.sort( copie , Comparator.comparing(Case::getNumeroCase) ); return copie; // on peut aussi écrire directement return lesCases.stream().sorted(Comparator.comparing(Case::getNumeroCase) ).collect(Collectors.toList()); } // on ajoute une nouvelle case, on s'assure que la liste reste triée public boolean add(Case e) { return lesCases.add(e) ; } @Override public String toString() { return "Plateau [nom = " + nom + ", \n lesCases = " + trier()+ ""; } }
Maintenant, on ne trie que lorsqu'on affiche, mais à chaque fois qu'on affiche, et on le fait sur une copie, ce qui fait que la liste d'origine n'est pas triée
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 public class Plateau { private List<Case> lesCases = new ArrayList<Case>(); // cette méthode trie la liste de cases private List<Case> trier(){ Collections.sort( lesCases , Comparator.comparing(Case::getNumeroCase) ); } // on ajoute une nouvelle case, on s'assure que la liste reste triée public boolean add(Case e) { return lesCases.add(e) ; } @Override public String toString() { trier(); return "Plateau [nom = " + nom + ", \n lesCases = " + lesCases + ""; } }
Là, on trie à chaque fois qu'on affiche la liste, au risque de la retrier alors qu'elle l'est déjà.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 public class Plateau { private List<Case> lesCases = new ArrayList<Case>(); // cette méthode trie la liste de cases passée en paramètre private void trier(List<Case> listCases){ Collections.sort( lesCases , Comparator.comparing(Case::getNumeroCase) ); } // on ajoute une nouvelle case, on s'assure que la liste reste triée public boolean add(Case e) { return lesCases.add(e) ; } @Override public String toString() { trier(lesCases); return "Plateau [nom = " + nom + ", \n lesCases = " + lesCases + ""; } }
Et ça ce serait la version qui correspondrait à ce que tu as fait, mais j'ai juste rendu private la méthode trier, parce qu'elle n'a aucun sens pour l'extérieur (ou alors ce serait une méthode utilitaire, qui pourrait être statique). Mais en fait, ça ne sert à rien ce paramètre : ça coûte juste un peu de la pile, c'est tout.

Citation:

Envoyé par St-42-FCM-57

Seulement, il me semble qu'en faisant ça, ma list n'est triée que pour le toString .

Et non, elle est triée définitivement, jusqu'à ce qu'on appelle à nouveau la méthode add, ou toute autre méthode qui modifierait la liste, parce que c'est bien l'instance correspondant à l'attribut qui est manipulée.
Citation:
Envoyé par St-42-FCM-57
Code:

1 2 lesCases.get(i).getNumeroCase()
--> comment sait on dans quel ordre doit-on mettre les instructions ?
Et bien, j'ai envie de répondre que c'est l'ordre logique. Mais c'est vrai que ça peut sembler évident, alors que cela ne l'est pas forcément pour tout le monde.

Tout d'abord la syntaxe de base est que lorsqu'un "élément" appartient à un autre, celui-ci est à droite du point, et le propriétaire donc à gauche. Ensuite, il faut juste procéder par étape.

Prenons un cas simple, simplfiiée (je mets tout en public pour qu'on n'ait pas besoin de méthodes).
Code:

1 2 3 4 5 6 7 8 9 public class Bicyclette { public Couleur couleur; public Bicyclette(Couleur couleur) { this.couleur = couleur ; } public Roue roue1; public Roue roue2; }
Pour accèder à la roue 1 de la bicyclette bleue (roue1 est attribut de bicyclette, bicyclette est le propriétaire de l'attribut) :
Code:

1 2 3 Bicyclette bicycletteBleue = new Bicyclette(BLEU); Roue roue = bicycletteBleue.roue1;
Jusque là pas de souci, n'est-ce pas ?

Maintenant, si on une classe Roue
Code:

1 2 3 4 5 6 7 public class Roue { public Pneu pneu; public Moyeu moyeu; public List<Rayon> rayons; }
Si tu veux manipuler son pneu, tu vas avoir un truc du genre :
Code:

1 2 3 Roue roue = ... Pneu pneu = roue.pneu;
Jusque là, toujours pas de souci, n'est-ce pas ?

Et si on voulait accèder au pneu de notre roue de byciclette bleue ?
Code:

1 2 3 4 Bicyclette bicycletteBleue = new Bicyclette(BLEU); Roue roue = bicycletteBleue.roue1; Pneu pneu = roue.pneu;
Jusque là, ça va toujours, n'est-ce pas ?

Et maintenant osons accèder directement au pneu de la bicyclette bleue sans passer par une variable roue intermédiaire :
Code:

1 2 3 Bicyclette bicycletteBleue = new Bicyclette(BLEU); Pneu pneu = bicycletteBleue.roue1.pneu;
Il n'y a pas de raison de changer l'ordre : c'est le pneu de la roue de la bicyclette en français, en Java, c'est bicycletteBleue.roue1.pneu... à gauche du point le propriétaire de ce qui est à droite de ce point

Maintenant, ce qui est bien c'est qu'avec les méthode c'est exatement pareil au niveau ordre, et cela quelque soit le type :

Code:

Pneu pneu = bicycletteBleue.roue1.getPneu();

ou

Code:

Pneu pneu = bicycletteBleue.getRoueAvant().getPneu();

ou

Code:

Rayon rayon = bicycletteBleue.getRoueAvant().getRayon(1);

ou

Code:

int nombreDeRayons = bicycletteBleue.getRoueAvant().getRayons().size();

ou

Code:

long longueurDeRayon = bicycletteBleue.getRoueAvant().getRayon(1).getLongueur();

etc.

Bonjour,

Citation:

Seulement, il y a un soucis avec ta méthode : elle prend un paramètre, or ce paramètre, pour que c'est un sens, il faut que cela soit l'attribut listeCases de l'instance de Plateau, attribut privé, donc inacessible de l'extérieur de la classe.

--> C'est exactement ce qui me posait problème !

Donc si je comprends entre ces 2 méthodes :
Code:

1 2 3 4 private void trier(List<Case> listCases){ Collections.sort( lesCases , Comparator.comparing(Case::getNumeroCase) ); }
et
Code:

1 2 3 4 private void trier(){ Collections.sort( lesCases, Comparator.comparing(Case::getNumeroCase) ); }
la différence est que : dans la première, elle trie uniquement la liste passée en paramètre, et la seconde ne trie uniquement celle de la classe Plateau ? Si tel est le cas, pourquoi la première ne s'écrirait pas de la sorte :
Code:

1 2 3 4 private void trier(List<Case> listCases){ Collections.sort( listCases , Comparator.comparing(Case::getNumeroCase) ); }
Concernant la méthode add :
Code:

1 2 3 4 5 6 7 8 9 10 public boolean add(Case e) { if ( lesCases.add(e) ) { trier(); return true; } else { return false; } }
Je ne suis pas sûr de bien la comprendre. Voici comment je la perçois : si on ajoute la case e à la liste lesCases, on trie cette liste, et on retourne vrai pour quitter la méthode add. Est-ce cela ?

J'ai également une autre question : qu'en est-il de ma fonction "trier" si je ne suis pas en Java 8 ? Car il m'arrive d'utiliser des PC sur Java 7 il me semble.

Merci pour la dernière partie, c'est vraiment très pédagogue ! Ca me parait bien plus clair maintenant, et dans le problème qui était le mien, on pourrait donc traduire :
lesCases.get(i).getNumeroCase() --> récupérer le numéro de la i-ième case.

Enfin, un grand merci pour toutes ces explications, très détaillées, mais ô combien utiles pour un novice comme je le suis ! Je suis vraiment reconnaissant de l'aide que tu m'apportes !

Citation:

Envoyé par St-42-FCM-57

la différence est que : dans la première, elle trie uniquement la liste passée en paramètre, et la seconde ne trie uniquement celle de la classe Plateau ?

Exactement. Le paramètre ayant le même nom que l'attribut, il "remplace" l'attribut lorsqu'on utilise son nom (on peut utiliser l'attribut en précisant this. devant).
Citation:
Envoyé par St-42-FCM-57
Si tel est le cas, pourquoi la première ne s'écrirait pas de la sorte :
Code:

1 2 3 4 private void trier(List<Case> listCases){ Collections.sort( listCases , Comparator.comparing(Case::getNumeroCase) ); }
Ah, oui, non, pardon... j'avais mal lu le nom du paramètre. Effectivement le nom du paramètre c'est listCases alors que l'attribut c'est lesCases. Donc on trie bien l'attribut effectivement, et le paramètre n'est pas utilisé. Autant le virer, il ne sert à rien et est un peu gênant pour l'appelant, puisqu'il faut passer un paramètre.
Citation:
Envoyé par St-42-FCM-57
Concernant la méthode add :
Code:

1 2 3 4 5 6 7 8 9 10 public boolean add(Case e) { if ( lesCases.add(e) ) { trier(); return true; } else { return false; } }
Je ne suis pas sûr de bien la comprendre. Voici comment je la perçois : si on ajoute la case e à la liste lesCases, on trie cette liste, et on retourne vrai pour quitter la méthode add. Est-ce cela ?
Oui. Ta méthode originale était :
Code:

1 2 3 4 public boolean add(Case e) { return lesCases.add(e); }
Ce qui pourait s'écrire :
Code:

1 2 3 4 5 public boolean add(Case e) { boolean resultat = lesCases.add(e); return resultat; }
A chaque fois qu'on ajoute un élément, les éléments dans la liste peuvent se retrouver potentiellement non triés. Comme on veut que la liste soit toujours triée, alors on la trie chaque fois qu'on ajoute un élément.
Code:

1 2 3 4 5 6 public boolean add(Case e) { boolean resultat = lesCases.add(e); trier(); return resultat; }
Mais comme resulat est false lorsque add n'ajoute pas l'élément (cf doc), alors il est inutile de perdre du temps à trier lorsque resultat est false, donc on ne le fait que lorsque resultat est true :
Code:

1 2 3 4 5 6 7 8 public boolean add(Case e) { boolean resultat = lesCases.add(e); if ( resultat ) { // e a été ajouté, lesCases n'est potentiellement plus triée, alors on la trie trier(); } return resultat; }
Si on supprime la variable resultat, on obtiendra
Code:

1 2 3 4 5 6 7 8 9 10 public boolean add(Case e) { if ( lesCases.add(e) ) { trier(); return true; } else { return false; } }
Citation:

Envoyé par St-42-FCM-57

J'ai également une autre question : qu'en est-il de ma fonction "trier" si je ne suis pas en Java 8 ? Car il m'arrive d'utiliser des PC sur Java 7 il me semble.

Java 7 n'est plus supporté depuis 2 ans, sauf en payant. Il serait préférable de migrer les postes. Mais soit, en pratique, c'est possible. Mais ça t'obligera à compiler en Java 7.

Pour trier en Java 7, comme les expressions lambda n'existent pas, il faut implémenter la classe Comparator.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Collections.sort( lesCases , new Comparator<Case> { public int compare(Case c1, Case c2) { // ici il faut retourner un nombre // qui vaut 0 lorsque c1 égal c2 // qui vaut -1 (en réalité un négatif, qui peut avoir une signification) lorsque c1 est avant c2 // qui vaut +1 (en réalité un positif) lorsque c2 est avant c1 // par exemple : return c1.getNumeroCase() - c2.getNumeroCase(); } } );
Pour éviter de créer une classe et une instance à chaque fois qu'on trie, on pourra faire une constante :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 private static final Comparator CASE_COMPARATOR = new Comparator<Case> { public int compare(Case c1, Case c2) { // ici il faut retourner un nombre // qui vaut 0 lorsque c1 égal c2 // qui vaut -1 (en réalité un négatif, qui peut avoir une signification) lorsque c1 est avant c2 // qui vaut +1 (en réalité un positif) lorsque c2 est avant c1 // par exemple : return c1.getNumeroCase() - c2.getNumeroCase(); } }; private void trier() { Collections.sort( lesCases , CASE_COMPARATOR ); }

29/04/2017, 15h25
St-42-FCM-57
Merci beaucoup pour tout le temps que tu m'as consacré, c'est vraiment sympa !

J'ai juste une petite zone d'ombre : pourquoi add est-il de type booléen ?

J'ai également voulu récupérer (dans la classe Plateau) le nom de la i-ème case.
J'ai fais ceci :
Code:

1 2 3 4 public String getNomCase(int caseIndex) { return lesCases.get(caseIndex).getNom(); }
En fait je voudrais que, quand je tape ça par exemple : System.out.println(Plateau1.getNomCase(2)); ça m'affiche "Boulevard de Belleville" ("boulevard de Belleville" étant le nom de la case getNumeroCase()==2);
Seulement, ça m'affiche tout le temps "null", je ne comprends pas bien ?

EDIT :
Non finalement ça marche, j'avais essayé avec des cases qui retournaient "null" dans getNom() ... :roll:

Juste une petite question: il me semble que les ArrayList commencent à 0 ? or moi j'ai numéroté mes cases à partir de 1.
Du coup j'ai fait ceci :
Code:

1 2 3 4 public String getNomCase(int caseIndex) { return lesCases.get(caseIndex-1).getNom(); }
Comme ça j'ai le bon nom qui est retourné, sinon tout est décalé de 1. Cependant, c'est un peu du bricolage je trouve, n'y aurait-il pas un moyen plus élégant pour résoudre ce "problème" ?

Citation:

Envoyé par St-42-FCM-57

Merci beaucoup pour tout le temps que tu m'as consacré, c'est vraiment sympa !

J'ai juste une petite zone d'ombre : pourquoi add est-il de type booléen ?
Code:

1 2 3 public boolean add(Case e) { return lesCases.add(e); }
De quel add parles-tu ? Celui de ArrayList (de List en fait), ou celui de Plateau. Pour celui de List, et bien, parce que c'est comme ça. La méthode a été codée comme ça, c'est tout. Enfin, par exactement. Ceux qui ont conçu l'interface se sont dit que dans le cas général, on pourrait avoir un refus d'ajout, et qu'on le signalerait à l'appelant en retournant false. Et pour celui de Plateau, et bien, c'est parce que tu l'as écrite comme ça. Il n'y a que toi qui sait pourquoi. Tu aurais pu écrire
Code:

1 2 3 public void add(Case e) { lesCases.add(e); }
A priori, il n'y pas de risque qu'on ne puisse pas ajouter une case dans la liste, lorsqu'il s'agit d'une ArrayList, sauf éventuellement qu'on dépasse la taille maximale d'une ArrayList, ce qui a vraiment peu de chances d'arriver. C'est un choix donc d'assumer que ça n'arrivera jamais et qu'on n'est pas obligé de retourner le résultat de List.add(). On peut même décider d'ajouter des règles :
Code:

1 2 3 4 5 6 public boolean add(Case e) { if( e==null || lesCases.contains(e) ) { // on ne met pas de null dans la liste, et on ne met pas une même instance de Case deux fois return false, } return lesCases.add(e); }
Ou on peut choisir de le faire sans possibilité de le savoir dans l'appelant :
Code:

1 2 3 4 5 public void add(Case e) { if( e!=null && !lesCases.contains(e) ) { // on ne met pas de null dans la liste, et on ne met pas une même instance de Case deux fois lesCases.add(e); } }
C'est un choix qui dépend de ce qu'on veut et doit faire.
:
Citation:
Envoyé par St-42-FCM-57
Juste une petite question: il me semble que les ArrayList commencent à 0 ? or moi j'ai numéroté mes cases à partir de 1.
Du coup j'ai fait ceci :
Code:

1 2 3 4 public String getNomCase(int caseIndex) { return lesCases.get(caseIndex-1).getNom(); }
Comme ça j'ai le bon nom qui est retourné, sinon tout est décalé de 1. Cependant, c'est un peu du bricolage je trouve, n'y aurait-il pas un moyen plus élégant pour résoudre ce "problème" ?
A quelques exception près, l'habitude en Java et que les index vont de 0 à taille de liste-1. Tu verras que ça a beaucoup d'avantages, pour les parcours, pour les extractions de sous-parties, pour certains calculs (passage de une dimension à deux dimensions par exemple), etc. Il faut prendre cette habitude pour tes propres modélisation, ce qui te permettra d'avoir un point de référence générale unique (excepté les exceptions malheureusement). Il faut que tu prennes également l'habitude et le réflexe de différencier les valeurs représentatives de tes états, et la façon qu'elles vont s'affichées. Même si tu veux afficher des numéros de 1 à n, il vaut mieux stocker 0 à n-1, justement pour pouvoir les utiliser comme index de tableau, de List, etc. Et seulement à l'affichage faire le + 1. Et à la saisie tu fais l'inverse.
Code:

1 2 3 4 5 6 7 8 9 public class Exemple { private int num; public int getNumero() { return num; } public String toString() { return String.valueOf(num+1); } }
Tu verras à l'usage que tu te prendras moins la tête et fera moins d'erreur. Tu verras qu'avec les nombres à virgules, les dates et tout le reste, on procède de même, et que procèder de manière commune, c'est toujours moins de risque d'erreur.

29/04/2017, 17h17
St-42-FCM-57

Oui je parlais de la classe add de la list, encore merci pour ces nouvelles explications.

J'ai donc changé la numérotation, en commençant à 0.

Cependant, il y a quelque chose qui n'est pas trop clair : comment fait-on pour modifier une valeur qui n'est pas dans mon Interface Case ?
Je m'explique. Si je veux changer le nom du propriétaire d'une case, je vais devoir créer un setProprietaire() dans la classe abstraite Propriete. Mais je n'ai un propriétaire que pour les classes qui étendent la classe abstraite Propriété (comme Terrain par exemple). Il serait donc illogique de mettre une méthode setNomProprietaire() dans l'interface Case ? Car des cases comme les cases Chance n'ont pas de propriétaire.

En fait, je voudrais accéder à un élément inférieur de l'arborescence, mais je ne trouve pas comment et, je ne sais pas si c'est possible.
Je rappelle mon "architecture" :
- Un plateau qui contient une list de Cases
- Interface Case
- implémentée par des classes telles que Chance
- mais aussi implémentée par une classe abstraite Propriete, qui elle-même est étendue par différentes classes comme Gare ou Terrain.

EDIT :
Pour résoudre mon problème, en attendant une réponse, j'ai donc mis une méthode void setProprietaire(Joueur propriétaire) dans l'interface Case. Seulement comme certaines classes n'ont pas de propriétaire, j'ai mis dans celles-ci une méthode setProprietaire, mais qui reste vide. Je ne pense pas cependant que ce soit la méthode à préconiser...

Il y a plusieurs façons de résoudre ça :

Comme tu l'as fait, ajouter une méthode setPropriétaire à l'interface Case. Mais tu dénatures la notion de Case. Dans le cas général des jeux de plateaux, la notion de propriétaire n'existe pas.. Elle n'existe que dans le cadre de certains jeux.

On peut, en Java 8 fournir une implémentation par défaut qui prend en compte cet aspect :

Code:

1
2
3
4
5
6
public interface Case {
  /**...**/
  default void setProprietaire(Proprietaire proprietaire) {
         throw new UnsupportedOperationException(); // par défaut la méthode n'est pas supportée, seuls les cases pour les jeux qui en ont besoin implémenteront cette méthode
  }
}

On peut également faire une interface spécialisée :

Code:

1
2
3
4
public interface CaseAvecProprietaire extends Case {
  /**...**/
  void setProprietaire(Proprietaire proprietaire);
}

Mais il faudra que la classe Plateau facilite sa manipulation, par exemple :

Code:

1
2
3
public class Plateau<T extends Case> {
          private List<T> cases = new ArrayList<T>();
 }

Code:

1
2
3
public class PlateauAvecProprietaire<CaseAvecProprietaire> {
    /**...*/
 }

On peut aussi gérer ça dans le joueur

Code:

1
2
3
4
5
6
7
8
9
10
11
12
public class Proprietaire extends Joueur {
    private List<Case> cases = new ArrayList<>();
    public void addCase(Case unecase) {
       cases.add(unecase);
    } 
    public boolean estProprietaire() {
       return !cases.isEmpty();
    }
    public boolean estProprietaire(Case unecase) {
       return cases.contains(unecase);
    } 
}

On peut gérer ça dans la case Plateau aussi, ou plutôt dans une classe spécialisée, par exemple avec une map

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
plublic class PlateauAvecProprietaire extends Plateau {
 
    private Map<Joueur, List<Case>> possessions = new HashMap<>();
 
   public void setProprietaire(Case unecase, Joueur joueur) {
	   if ( estPossedee(unecase) ) { // si une case ne peut être possédée que par un seul joeur à la fois
		   throw new IllegalStateException("Case déjà possédée");
	   }
	   possessions.compute(joueur, (k,v)-> {
		   if ( v==null ) {
			   v=new HashSet<>();
		   }
		   v.add(unecase);
		   return v;
	   });
	   /*// ou en Java 7-
	   List<Case> lescases = possessions.get(joueur);
	   if ( lescases==null ) {
		   possessions.put(joueur, lescases = new ArrayList<>());
	   }
	   lescases.add(unecase);*/
   }
 
   public Set<Case> getPossessions(Joueur joueur) {
	   Set<Case> lescases = possessions.get(joueur);
	   if( lescases==null ) {
		   return Collections.emptySet();
	   }
	   return Collections.unmodifiableSet(lescases);
   }
 
   public boolean estProprietaire(Joueur joueur) {
	   return possessions.containsKey(joueur);
   }
 
   public Joueur getProprietaire(Case unecase) {
	   for(Map.Entry<Joueur,Set<Case>> entry : possessions.entrySet()) {
		   if ( entry.getValue().contains(unecase) ) return entry.getKey();
	   }
	   return null;
   }
 
   public Set<Joueur> getProprietaires(Case unecase) {
	   return possessions.entrySet().stream().filter(e->e.getValue().contains(unecase))
			  .map(Map.Entry::getKey).collect(Collectors.toSet());
	   /*
	   Set<Joueur> joueurs = new HashSet<>();
	   for(Map.Entry<Joueur,Set<Case>> entry : possessions.entrySet()) {
		   if ( entry.getValue().contains(unecase) ) joueurs.add(entry.getKey());
	   }
	   return joueurs;
	   */
   }
 
   public boolean estProprietaireDe(Joueur joueur, Case unecase) {
	   return getPossessions(joueur).contains(unecase);
	   /*// ou
	   if ( estProprietaire(joueur) ) {
		   return possessions.get(joueur).contains(unecase);
	   }
	   else {
		   return false;
	   }*/
   }
 
   public void supprimeProprietee(Joueur joueur, Case unecase) {
	   if ( estProprietaire(joueur) ) {
		   possessions.get(joueur).remove(unecase);
	   }	   
   }
 
   public void supprimeTouteProprietee(Joueur joueur) {
	   possessions.remove(joueur);	   
   }
 
   public boolean estPossedee(Case unecase) {
	   for(Set<Case> set : possessions.values()) {
		   if ( set.contains(unecase) ) return true;
	   }
	   return false;
   }
 
   // etc
 
}

30/04/2017, 15h52
St-42-FCM-57

Bonjour,

J'ai essayé la première méthode, et ça à l'air de fonctionner comme je le souhaite. Je verrai par la suite si c'est mieux de laisser comme ça, ou de prendre une autre méthode que tu as suggéré.

En fait pour moi, qui suis débutant en java, le plus dur c'est de comprendre comment interagir entre les différentes classes ou interfaces.
Par exemple, là, j'ai ma classe ParcGratuit, qui sert en gros à stocker l'argent des impôts, et qui implémente Case. Elle comporte une méthode setCagnotte qui doit me permettre de changer justement la cagnotte du parc gratuit. Et je ne comprends pas pourquoi, lorsque dans une autre classe je fais ParcGratuit.setCagnotte(200) par exemple, ça me met une erreur ?

EDIT :
En fait, j'ai fait quelque chose, mais je ne suis pas sûr d'avoir fait la bonne chose, je n'ai peut-être que contourné le problème.
Dans mon main, j'ajoute toutes les cases au plateau (ça ce n'est pas nouveau, je le fais depuis le début), et donc un moment je fais "ParcGratuit parcgratuit= new ParcGratuit...".

Du coup pour modifier la valeur je peux faire parcgratuit.setCagnotte(200). Seulement je fais ceci dans le main, ne puis-je pas le faire dans une classe ? Je ne sais pas si je suis clair... :(