Bonjour à tous, j'ai un petit problème pour un programme que je suis en train de faire, en fait il s'agit ici plutot d'un jeu de société du genre monopoly pour m'entrainer un peu et j'ai un problème avec mes appels de méthodes. C'est un jeu au tour à tour et pour faire mes appels de methode je dois faire par exemple:
 
joueur1.getArgentJoueur();
 
 
mais est il possible de faire appel avec un numero de joueur variable comme:
 
joueur.getArgentJoueur();
 
Comme c'est un jeu au tour par tour joueur varie entre 1 et le nombre total de joueur.
J'espère que je me suis bien fait comprendre et si vous pouviez me donner une solution même un truc différent ca m'aiderait.
Merci

J'ai rien compris perso.

Salut,
 
Oui c'est possible....
Suffit que chaque fois que tu crées un nouveau joueur tu le mettes dans un Vector (tableauJoueurs par exemple). Ensuite tu pourra "tirer" le joueur désiré du vector en appelant le bon index et voilà :
 

tableauJoueurs.get(index).getArgentJoueur();

Je suis encore debutant donc je connais pas bien encore tous les trucs mais Vector est ce quelque chose qu'on peut comparer aux structures du langage C avec plusieurs champs? ou c'est juste un tableau?

C'est un tableau. Qu'il ne faut pas utiliser d'ailleurs, c'est une collection dépréciée, il est conseillé d'utiliser ArrayList (ou une autre collection implémentant List, mais AL est la plus basique) pour des séquences.

Accessoirement, et pour une utilisation cyclique (joueur 1 -> joueur 2 -> joueur 3 -> joueur 4 -> joueur 1) je suggérerais plutôt d'utiliser une collection FIFO, genre une implémentation de Queue. Ou même une collection custom (backée par une queue via composition) qui gère ta mainloop via délégation, mais là il faut plus d'info sur le programme et la structure actuelle, sinon c'est de l'astronautique architecturale.

Dépréciée? Je savais pas  
Pourquoi c'est pas marqué dans la doc ( http://java.sun.com/javase/6/docs/ [...] ector.html )

Elle est pas formellement dépréciée (parce que de vieilles APIs l'utilisent encore, il y en a plein Swing par exemple), mais elle ne sert plus à rien (ArrayList fait tout ce que Vector fait en aussi bien) et dans la mesure où elle a été altérée à l'introduction des Collections elle a une interface immonde avec des masses de méthodes en double

Le seul avantage qu'elle peut avoir, c'est d'être synchronisée alors qu'ArrayList ne l'est pas (à dessein), et il suffit de composer ArrayList avec Collections.synchronizedList pour avoir la même chose avec une interface plus propre.

En général, Vector tend à être la marque de vieux code ou d'un apprentissage discutable.

Note par contre que si avec les anciens JDK (jusqu'à 1.4 sûr, probablement 1.5) il y avait une différence de perf notable (~20% en 1.4 sur du single threadé), avec les optimisations du runtime récentes (escape analysis, lock coarsening, lock elision) les perfs sont équivalentes.

Idem pour Hashtable et HashMap btw.

Ok, merci beaucoup
Je note

J'ai rien compris à la collection custom masklinn. Comment se fait il que pour un truc si simple on doit utiliser des trucs si compliqué... je veux juste que lorsque le tour passe au joueur suivant je puisse utiliser les methodes sans avoir a tout mettre en dure. ex
au lieu de faire  
 
joueur1.getArgent();
joueur2.getArgent();
joueur3.getArgent();
joueur4.getArgent();
 
faire par exemple:
 
for(joueur=1;joueur<=4;joueur++)
{
      joueur.getArgent();
}
 
ou quelque chose du genre

1. Il n'y a rien de compliqué dans ce dont j'ai parlé
2. C'est juste une suggestion pour rendre le reste du code plus clair et plus simple, après tu fais ce que tu veux hein perso je m'en fous

Utiliser un tableau (ou Vector ou List ou n'importe quoi qui y ressemble) si tu trouves ça compliqué tu ne vas pas aller loin. C'est vraiment la base.
Il suffit de créer ce tableau le remplir de tes Joueurs et de parcourir le tableau ensuite.
Exemple :

List<Joueur> liste = new ArrayList<Joueur>()
liste.add(joueur1);
liste.add(joueur2);
...
for(Joueur j : liste){
   j.getArgent();
}

Après si tu veux pas utiliser de tableau ou liste tu peux toujours utiliser l'introspection pour parcourir tous les membres qui commencent par "joueur" mais là pour le coup ça devient compliqué.
Mais déjà avoir x membres dans une classe Joueur1, ..., JoueurX c'est quand même vraiment pas propre. Imagine un jour tu veux ajouter un joueur...

Non mais le ArrayList je trouve ca tres simple mais quand on me dit  
 
"Ou même une collection custom (backée par une queue via composition) qui gère ta mainloop via délégation, mais là il faut plus d'info sur le programme et la structure actuelle, sinon c'est de l'astronautique architecturale."
 
Pour moi c'est du chinois, comme je l'ai dis plus haut je commence le java, j'ai fait du fortran et du C et y a toujours eu des methodes tes simple. Je vais reessayer avec le arrayList parce que quand j'appelle ma methode il apprecie pas que ca soit une variable avant le point.

 
Très simple en C... S'amuser avec les pointeurs d'une structure Joueur...  

C'est bien ce que je dis.. mais la on fait du java

C'était ironique mon post. Je veux dire que Java est beaucoup plus simple que le C.

En quoi?
 
Collection => une collection, genre une liste, une map, un set, whatever, plus spécifiquement pour java http://java.sun.com/docs/books/tut [...] index.html
 
custom => que tu crées toi même
 
(backée par une queue via composition) => se rattache à la partie précédente du post: une queue (une collection First In, First Out) est une implémentation acceptable pour un jeu avec tes "tours" statiques: tu colles tous tes joueurs dedans (dans l'ordre), tu sors le premier joueur de ta queue tu en fais ce que tu veux puis tu le remet dans ta queue... à la fin. Tu vas donc avoir en permanence le "prochain joueur" en tête de queue. Donc dans ta collection custom tu utilises une queue pour stocker tes joueurs, la collection gérant simplement "dequeue, appliquer opérations, enqueue" pour toi.
 
Mainloop => bah c'est la partie qui exécute un tour de jeu
 
délégation => ta collection custom, tu vas lui dire un truc genre players.nextTurn(operation) où opération sera un objet avec une méthode quelconque qui exécutera un tour de jeu. En interne, la collection va dequeue un joueur, appeler operation en lui filant le joueur qui va bien puis enqueue le joueur. Donc la collection délègue à ton objet "magique".

Sinon, tu peux essayer d'utiliser un tableau de joueurs:

 
 
Merci de ne pas poster ces imbécillités.

Je ne vois pas en quoi c'est imbécile... C'est simple et ça répond au besoin...

Et quand il aura 6 joueurs, il fera comment? Il modifiera tous ses for et recompilera ?
Et s'il veut qu'on puisse choisir dans le jeu le nombre de joueurs? Lit la solution de Masklin (qui n'est en rien plus complexe) et tu comprendras le pourquoi du comment

Soit. Tu aurais pu simplement répondre ça, au lieu d'être méprisant.

pour pouvoir changer le nombre de joueur dans la boucle qu'il propose il suffit de remplacer le 4 par une variable N définie précédemment (où est le pb ?). Ceci dit je trouve le principe de queue assez sympathique par rapport au simple tableau.

Merci pour votre aide mais j'avais déjà pensé à tout ça mais le problème c'est que si par exemple j'appelle ma méthode comme ça:
 
identifiant.getNomJoueur()
avec identifiant en dure ca va marcher parfaitement, mais si identifiant est une variable je vais avoir une erreur:
"The method getNomJoueur() is undefined for the type String"

j'ai oublié de préciser, la variable identifiant est déclaré comme cela:
static String identifiant;

forcément si identifiant est un String il ne peut pas avoir la méthode getNomJoueur

comment je doit déclarer la variable identidiant alors pour que ça puisse marcher?

du même type que l'objet qui contient la méthode.

Joe tu sembles avoir du mal à comprendre les principes de base de l'orienté objet.
 
Tu dois déclarer une classe Joueur qui contient les définitions de toutes les méthodes que tu peux appeler sur un joueur: getNom() getScore() et autres.
 
Ensuite pour chaque nouveau joueur dans ta partie, tu instancies un nouvel objet de type Joueur et tu l'assignes à une variable de type Joueur. Tu pourras alors appeler getNom() dessus.
 
Comme tu auras plusieurs joueurs, tu peux les stocker dans un tableau ou dans une structure de données comme une liste (ArrayList, LinkedList, peu importe). ArrayList fonctionne comme un tableau de taille dynamique: au début il est vide, ensuite tu peux ajouter les joueurs dedans au fur et à mesure sans devoir te soucier du redimensionnement du tableau.

oui je debute en objet donc je suis pas encore tres tres au point, mais sinon j'ai bien une classe Joueur qui a été créé et donc la getNomJoueur est une methode déclaré comme ca:
 
public String getNomJoueur(){
  return nomJoueur;
 }
 
je sais utiliser les arraylist ou des tableaux avec des données normales comme des string ou entiers mais j'arrive pas à l'utiliser avec ma methode pour une recherche dynamique par exemple
joueur[i].getNomJoueur()

Je répète ce que j'avais déjà écrit au dessus :
 

List<Joueur> liste = new ArrayList<Joueur>()
liste.add(joueur1);
liste.add(joueur2);
...
for(Joueur j : liste){
   j.getArgent();
}

 
Et pour avoir le n-ème de ta liste de mémoire ça doit être liste.get(n)

On ne peut pas t'aider si tu ne donnes pas plus de détails, qu'entends-tu par une recherche dynamique?