TP2 :´Ecriture d`une application en utilisant la POO

TP2 : Écriture d’une application en utilisant la POO
[email protected]
R&T 2ème année
Vous avez à votre disposition (sur le répertoire commun) : le cours, les TDs,
et quelques documents provenant d’Internet. Vous devez prendre l’habitude de rechercher l’information dans ces documents et dans le sujet de TP. Chaque question
inutile1 sera notée et aura des conséquences sur la note du TP.
A la fin du TP, envoyez par mail les fichiers .java présents dans le répertoire
src du répertoire TP2 de votre répertoire de travail Eclipse. Si je ne reçoit pas ces
fichiers (et seulement cela), votre note sera nulle.
But du TP : Créer un programme basé sur plusieurs classes en utilisant l’héritage,
la composition,. . .
1 Jeu de cartes
Avant de commencer votre TP, créez un nouveau projet TP2 dans Eclipse.
1.1 Règle du jeu
Parmi les nombreux jeux de cartes, la bataille est l’un des jeux les plus simple.
Chaque joueur reçoit la moitié des cartes du paquet au début de la partie. Ensuite,
chaque joueur pose la carte qui est au dessus de son paquet. La carte la plus forte
gagne, en cas d’égalité, les deux cartes sont “perdues”.
1.2 Présentation de l’application
L’application sur laquelle vous allez travailler doit simuler une partie de cartes.
Pour simplifier le nombre de classe, le jeu de cartes est seulement composé de 4 as,
4 rois, 4 reines et 4 valets. Le diagramme UML de l’application est présenté dans la
figure 1.
1.3 Classe de test
La première classe à construire est une classe de test ayant simplement une
méthode main ce qui va vous permettre de pourvoir tester vos classes les unes
après les autres. Cette classe n’est pas représentée dans le diagramme UML.
1
qui a sa réponse de manière simple dans les fichiers fournis
1
1.4 La classe Carte
Créez la classe Carte, n’oubliez pas qu’elle est abstraite (cochez la case abstract
dans la boite de création de classe).
Implémentez le constructeur, l’entier reçu en paramètre doit être placé dans
l’attribut valeur, la chaı̂ne de caractères dans l’attribut Nom.
Pour implémenter la méthode getValeur, utilisez l’assistant : dans l’éditeur,
cliquez sur le bouton droit et choisissez le menu Source puis Generate Getters and
Setters et choisissez le bon élément.
La méthode toString La méthode toString est présente dans la classe Object
et donc dans toutes les classes grâce au mécanisme d’héritage. Par défaut elle
renvoie une chaı̂ne de caractères suivie d’une chaı̂ne hexadécimale (le hashcode
de l’objet. . .). Cette méthode est souvent surchargée pour modifier la chaı̂ne de
caractères renvoyée.
Cette méthode est appelée automatiquement à chaque fois qu’une chaı̂ne de
caractères est attendue à la place d’un objet. Par exemple,
MaClasse unObjet;
unObject = new MaClasse();
System.out.println(unObject);
/* est identique a */
System.out.println(unObject.toString());
Pour surcharger cette méthode dans la classe Carte, utilisez l’assistant de
génération de code : cliquez sur le bouton droit et choisissez le menu Source puis
Override/Implements Methods
Dans la classe Carte, la méthode toString doit renvoyer le nom de la carte
(Nom).
1.5 Les classes As, Roi, Dame et Valet
Ces quatre classes héritent de la classe Carte. Seules les valeurs des attributs
changent selon la classe. Le tableau ci-dessous donne pour chaque classe les valeurs d’initialisation :
Valeur
Classe Nom
As
As
10
Roi
5
Roi
Dame
Dame
3
Valet
2
Valet
Dans le constructeur de chaque classe fille, il suffit de placer le mot clé super()
pour appeler un constructeur de la classe mère. Si il y a des arguments dans les
parenthèses, le constructeur correspondant aux arguments et automatiquement
appelé.
Dans notre cas, il faut placer les arguments d’appel du constructeur (une chaı̂ne
de caractère et un entier dans les parenthèses) pour que les valeurs soient initialisées comme voulues.
2
Exemple pour la classe As :
public As(){
super("As",10);
}
1.6 La classe Joueur
Commencez par écrire tous les attributs puis les assesseurs (get. . .) à l’aide de
l’assistant.
Écrivez ensuite les déclarations de toutes les méthodes restantes.
Le constructeur doit initialiser l’attribut nom avec la chaı̂ne de caractères passée
en paramètre. Il doit aussi initialiser les attributs score et nombreDeCarte à 0. Il
doit aussi créer le tableau cartes pour qu’il contienne 8 objets de la classe Carte
(ou de l’un de ses classe fille).
La méthode AjouterAuScore, ajoute ( !) à l’attribut score la valeur reçue en
paramètre.
Pour remplir le tableau cartes, on utilise la méthode AjouterUneCarte. Cette
méthode reçoit un objet de type Carte qui est placé à la position nombreDeCartes
du tableau cartes, ensuite nombreDeCartes est incrimenté.
La dernière méthode la classe est PoserUneCarte. Si il y a encore des cartes
(nombreDeCartes supérieur à 0), une carte est renvoyée par la méthode et le
nombreDeCartes est diminuée de 1.
1.7 La classe Jeu
Commencez par écrire la classe Jeu, son attribut et les déclarations des deux
méthodes et du constructeur.
Le constructeur doit créer le tableau lesCartes pour qu’il puisse contenir 16
objets de la classe Carte (ou de l’un de ses classe fille). Ensuite, il doit créer 4 objets
de chacune des classes filles de Carte et les placer dans le tableau lesCartes.
La méthode Melanger utilise un générateur aléatoire (Random) pour réaliser 100
permutations dans le tableau lesCartes Pour chaque permutation, tirez deux valeurs aléatoires et permutez les deux cases correspondantes du tableau.
Cette méthode est privée, elle ne peut être appelée que dans la classe. Ajoutez une ligne dans le constructeur pour qu’elle soit appelée après la création des
différents éléments.
Toutes les cartes (le contenu du tableau lesCartes) sont distribuées entre les
deux joueurs par la méthode Distribuer. Cette méthode ajoute une carte sur deux
à chaque joueur en utilisant la méthode AjouterUneCarte de la classe Joueur.
1.8 La classe Partie
Comme précédemment, écrivez la classe à partir du diagramme UML, la déclaration
de ses méthodes et ses attributs.
Les constructeur de cette classe doit :
– Créer l’attribut unJeuDeCarte
3
– Créer les attributs JoueurA et JoueurB avec les chaı̂nes de caractères passées
en paramètres du constructeur.
– Une fois ces éléments crées, la méthode Distribuer de l’objet référencé par
l’attribut unJeuDeCarte est appelée avec les objets référencés par les attributs JoueurA et JoueurB comme paramètres d’appel. Les cartes sont ainsi
automatiquement distribuées entre les différents joueurs.
– L’attribut Tour est mis à 0.
La méthode FaireUnTour simule un tour de jeu. Elle demande une carte à
chaque joueur en utilisant la méthode PoserUneCarte. La valeur des deux cartes
est comparée, le joueur qui a la carte la plus forte gagne la manche, et son nombre
de points est augmenté de la somme des deux cartes. En cas d’ex-aequo, aucun
des joueurs ne gagne. L’affichage voulue doit être de la forme suivante “Roi contre
As Paul gagne 15 point(s)”, en cas d’égalité l’affichage est du type “As contre As”. A
la fin de la méthode, le nombre de tour (attribut Tour) est incrémenté.
La méthode FaireUnePartie appelle la méthode FaireUnTour tant que les deux
joueurs ont encore des cartes. Elle affiche le numéro de chaque tour. A la fin de la
partie, la méthode doit afficher un message du type “Pierre gagne, 30 à 10” ou
“Match nul” si les deux joueurs ont le même nombre de points.
A la fin du TP, la classe de test doit demander le nom des deux joueurs, créer un
objet de la classe Partie en utilisant ces nom et appeler la méthode FaireUnePartie.
4
Jeu
- lesCartes : Carte[]
+ Jeu()
- Melanger() :
+ Distribuer(Joueur premierJoueur, Joueur secondJoueur) :
1
Joueur
16
8
Carte
- Valeur : entier
- Nom : Chaine
+ Carte(chaine uneChaine,entier unEntier)
+ getValeur() : entier
+ toString() : Chaine
- nom : Chaine
- cartes : Carte[]
- score : entier
- nombreDeCartes : entier
+ Joueur(Chaine unNom)
+ getNom() : Chaine
+ getScore() : entier
+ getNombreDeCartes() : entier
+ AjouterAuScore(entier uneValeur) :
1 + AjouterUneCarte(Carte uneCarte) :
+ PoserUneCarte() : Carte
2
1
Partie
As
Roi
Dame
Valet
+ As()
+ Roi()
+ Dame()
+ Valet()
- unJeuDeCarte : Jeu
- JoueurA : Joueur
- JoueurB : Joueur
- Tour : entier
+ Partie(Chaine nomA, Chaine nomB)
+ FaireUnTour() :
+ FaireUnePartie() :
F IG . 1 – Schéma UML des différents éléments du programme
5