Série notée – Sujet 2 - The IC Home Page is in:ic.epfl.ch

Transcription

Série notée – Sujet 2 - The IC Home Page is in:ic.epfl.ch
EIDGENÖSSISCHE TECHNISCHE HOCHSCHULE – LAUSANNE
POLITECNICO FEDERALE – LOSANNA
SWISS FEDERAL INSTITUTE OF TECHNOLOGY – LAUSANNE
Faculté Informatique et Communication
Cours Introduction à la POO
Jamila Sam
Règles et recommandations :
1. La série est à réaliser individuellement. L’échange d’informations est strictement interdit (y
compris l’échange de documents).
2. La série doit impérativement être réalisée sur les terminaux des salles CO020-023 et sur votre propre
compte. Il ne doit y avoir qu’un seul login sur votre compte durant le temps de la série
notée.
3. Vous pouvez amener votre propre clavier, mais il vous appartient de tester avant la série que ce
matériel fonctionne correctement.
Série notée – Sujet 2
Instructions
– Max 1h45
– Max 120 points (+ 15 en bonus)
1. Dans un navigateur, ouvrez la page se trouvant sous la rubrique Séries d’exercices de la page
web du cours suivez scrupuleusement les instructions qui apparaissent.
2. Vous pouvez ouvrir à nouveau le navigateur une fois ces manipulations faites, pour consulter la
page web du cours.
3. Pour RENDRE la série notée, en fin d’examen :
(a) Cliquez à nouveau sur le lien série notée et allez au point 3 des instructions. Le menu qui
apparaı̂t comporte déjà le nom du fichier à rendre.
(b) Pour envoyer un fichier, cliquez sur le bouton Browse correspondant au nom du fichier et
sélectionnez le fichier en question dans la liste qui vous est proposée. Cliquez ensuite sur le
bouton Envoyer.
Les fichiers suivants sont à envoyer, même si non abordés :
De.java, Rando.java, Piraterie.java, Extra.java
Pour terminer, n’oubliez pas de VALIDER VOTRE ENVOI.
4. Il n’est pas permis : d’utiliser du matériel électronique, d’envoyer des emails, de vous connecter sur
une autre machine ou d’imprimer pendant la durée de la série notée.
5. Documents autorisés: les documents du cours (transparents, séries, corrigés). Il vous est possible de
consulter cette documentation, et seulement celle-là, en ligne. 1–3 livres de référence sur le langage
Java, au plus 100 feuilles de notes personnelles. En cas de doute, demandez l’avis de l’assistant
responsable.
6. Il est impératif de mettre vos numéros SCIPER en commentaire au début de chacun de vos
fichiers.
7. Vous commenterez les parties “délicates” de votre code (ceci peut-être fait en anglais).
8. Lisez attentivement chaque question de façon à ne faire que ce qui vous est demandé, et servezvous de l’exemple de fonctionnement accompagnant les exercices pour vérifier votre solution. Si
l’énoncé ne vous paraı̂t pas clair, ou si vous avez un doute, demandez des précisions à
l’un des assistants.
9. Si pour des raisons de langue, vous ne comprenez pas bien ce qui vous est demandé, n’hésitez pas
à faire appel à un assistant pour obtenir des clarifications.
10. Sauf mention explicite, les affichages ne doivent pas obligatoirement correspondre à ceux donnés
en exemple de fonctionnement; les mêmes informations doivent être affichées, mais le format peut
être différent.
11. La série comporte 4 exercices indépendants.
12. Le fait que le code soit compilable ou exécutable compte dans la notation mais ne constitue pas le
seul critère. La correction tiendra compte également des “solutions approchées”.
SU
IT
SU
IT
E
E
À
À
LA
LA
PA
GE
PA
GE
SU
IV
AN
TE
SU
IV
AN
TE
Exercice 1 : Jeu de dés (20 points)
Exercice 2 : Comparaisons (5 points, bonus)
Il s’agit dans cet exercice de simuler une partie de jeu de dé. Vous travaillerez dans le fichier fourni
De.java
Le fichier fourni Extra.java contient un programme qui compare la composition de deux bouquets de
roses.
Le programme demande à l’utilisateur :
– de combien d’argent dispose le joueur
– quel est le nombre maximal de tours autorisés pour une partie.
Les deux bouquets sont chacun constitués de deux roses rouges et devraient donc être considérés comme
identiques.
On s’attend donc à ce que le programme affiche true or il affiche false.
Le programme simule ensuite une partie de jeu de dé comme suit :
– à chaque tour le joueur mise un montant (qui sera décompté de son argent);
– la mise initiale est toujours de 2 francs;
– tant qu’il reste de l’argent au joueur et que le nombre maximal de tour n’est pas atteint :
1. le joueur mise le double de sa mise précédente. Si la mise dépasse la somme d’argent du joueur,
il ne misera que sa somme.
2. il lance le dé;
3. s’il gagne, le total misé s’ajoute à son argent sinon il recommence au point 1.
– Chaque lancer de dé correspond à un tour.
– Lorsque le joueur sort de la partie le programme doit afficher:
– le montant d’argent dont il dispose (s’il lui reste de l’argent)
– sinon un message lui indiquant le nombre de tours qu’il lui a fallu pour perdre tout son argent.
Il vous est demandé d’écrire le programme De.java qui réalise ce traitement.
Pour simuler le lancer de dé, il suffit de tirer un nombre aléatoire au moyen de Math.random(). Si ce
nombre est inférieur à 0.5 le joueur a perdu sinon il a gagné.
Il n’est pas nécessaire de modulariser le code pour cet exercice.
Exécuter votre programme plusieurs fois avec 20 pour le montant d’argent et 5 pour le nombre de tours
vous devriez obtenir ces deux types d’exécutions:
Combien d’argent avez-vous pour jouer à une partie de dé?
20
Quel est le nombre de tours maximal autorisé par partie?
5
Félicitations vous quittez le jeu avec 36 CHF.
ou
Combien d’argent avez-vous pour jouer à une partie de dé?
20
Quel est le nombre de tours maximal autorisé par partie?
5
Désolé, vous avez perdu tout votre argent en 4 tours.
1. ajouter au fichier Extra.java un commentaire expliquant le pourquoi de cet affichage;
2. corriger le problème en ajoutant une seule méthode à la classe Rose.
Le reste du programme doit rester inchangé.
Suite de l’énoncé à la page suivante −→
Exercice 3 : Randonnée (15 points + 10 en bonus)
S’il y a plusieurs étapes candidates la méthode retournera la dernière. Si le circuit est vide la méthode
doit retourner -1.
Un organisateur de randonnées souhaite écrire un programme pour l’aider à choisir un parcours.
Il a ébauché le programme du fichier Rando.java.
La méthode displayStep permet d’afficher les résultats de stepMinDiff selon l’exemple d’exécution
fourni plus bas et doit être conforme à la méthode main fournie.
Dans son programme un circuit tel que:
Pour tester le programme implémenté jusqu’ici, décommentez la partie du programme principal comprise
entre // TEST 2 et // FIN TEST 2.
2
7
3
5
8
est représenté par le tableau : {3, 8, 5, 7, 2}
Les valeurs du tableau sont les distances séparant les étapes :
– la distance de l’étape 0 est de 3 km,
– celle de l’étape 1 est de 8 km,
– etc.
On suppose ici que tous les parcours sont des circuits qui peuvent être parcourus en boucle :
l’étape suivant la dernière est la première
Il vous est demandé de compléter le programme ébauché en codant les méthodes manquantes. Ces
méthodes se conformeront strictement à la méthode main.
La méthode totalLength (4 points)
Cette méthode prend en argument un circuit et retourne sa longueur (somme des longueurs des différentes
étapes).
Pour tester le programme implémenté jusqu’ici, décommentez la partie du programme principal comprise
entre // TEST 1 et // FIN TEST 1.
Vous devriez obtenir la trace d’exécution suivante :
Test2:
-----L’etape ayant le plus faible ecart de longueur avec la suivante est la : 4
Circuit vide
La méthode selectCircuit (Bonus, 10 points)
Tous les circuits sont de mêmes longueurs. Un ensemble de circuits est représenté par un tableau de
tableaux.
La méthode selectCircuit prend en argument un ensemble de circuits et affiche celui dont :
– la longueur vaut au moins 22 km;
– et l’étape avec le plus faible écart de distance avec sa suivante est la plus proche de l’étape 0.
S’il y a plusieurs circuits candidats le premier sera retenu.
Si aucun circuit ne satisfait les critères voulus, un message approprié sera affiché (voir trace d’exécution
ci-dessous).
Pour tester le programme implémenté jusqu’ici, décommentez la partie du programme principal comprise
entre // TEST 3 et // FIN TEST 3.
Test3:
-----Le circuit choisi est le : 2
Pas de sortie cette annee !
Pas de sortie cette annee !
Vous devriez obtenir la trace d’exécution suivante :
Test1:
-----25 km
0 km
Suite de l’énoncé à la page suivante −→
Les méthodes stepMinDiff et displayStep (11 points)
La méthode stepMinDiff prend en argument un circuit et retourne l’indice de l’étape ayant le plus faible
écart de distance (en valeur absolue) avec la suivante. La méthode Math.abs peut-être utilisée.
Par exemple pour le circuit {3, 8, 5, 7, 2}
suivante (la 0) n’est que de 1 alors que :
– l’écart de distance entre l’étape 0 et 1
– l’écart de distance entre l’étape 1 et 2
– l’écart de distance entre l’étape 2 et 3
cette étape est la 4 car l’écart de distance entre l’étape 4 et la
est de 5;
est de 3;
est de 2;
Exercice 4 : Bataille navale (70 points)
Nous nous intéressons dans cet exercice à modéliser de façon très basique un jeu de bataille navale avec
des navires. Ces derniers pourront être des navires pirates et des navires marchands.
Voici les éléments devant être modélisés :
1) Les navires (Héritage, polymorphisme, 45 points)
Il s’agit d’abord d’implémenter une classe Navire, permettant de représenter un navire.
– les navires peuvent se déplacer et se rencontrer. Ils peuvent être amis ou ennemis.
– deux navires sont amis s’ils ont le même drapeau et ennemis sinon
– les navires pirates peuvent attaquer les autres navires et les couler dans certaines conditions.
La classe Navire (21 points)
Un Navire est caractérisé par :
– une coordonnée en x et une coordonnée en y permettant de repérer sa position dans l’espace (deux
entiers pour simplifier);
Vous prendrez note des directives suivantes avant de commencer à coder :
1. Vous travaillerez dans le fichier Piraterie.java et n’utiliserez pas d’autres fichiers. Quelques
éléments y sont déjà fournis :
– un drapeau (sous la forme d’un entier) indiquant à quel camp appartient le navire.
– une information indiquant s’il est coulé;
– quelques constantes;
La classe Navire comportera :
– un programme principal auquel votre code devra strictement se conformer.
– un constructeur initialisant les coordonnées et le drapeau du navire au moyen de valeurs passées en
paramètre. Le navire ”construit” ne sera pas marqué comme coulé d’emblée!
Ce programme ne doit pas être modifié d’une autre façon que ce que l’énoncé vous suggère.
2. Vous implémenterez des méthodes get et set uniquement si elles s’avèrent vraiment nécessaires
pour le fonctionnement du programme tel que demandé.
3. Votre code sera proprement encapsulé. L’utilisation de protected n’est pas permise.
4. Votre programme devra être bien modularisé et évitera la duplication de code.
5. Si vous le jugez utile, vous êtes libres d’ajouter d’autres méthodes à celles qui vous seront explicitement demandées.
– les getters getX, getY et getFlag retournant les coordonnées du navire et son drapeau;
– la méthode bool isSunk() retournant vrai si le navire est coulé;
– la méthode distance, conforme à la méthode main fournie, et retournant la distance (un double)
séparant lep
navire d’un autre navire. La distance entre deux points (x1 , y1 ) et (x2 , y2 ) se calcule selon
la formule (x1 − x2 )2 + (y1 − y2 )2
– la méthode void move(int unitsX, int unitsY) permettant de déplacer le navire de unitsX unités
horizontalement et de unitsY unités verticalement (unitsX et unitsY peuvent être négatifs).
– la méthode void sink() permettant de marquer le navire comme coulé;
Il vous est demandé d’implémenter la classe Navire, de manière à ce que les contraintes suivantes soient
respectées :
1. les coordonnées du navire ne peuvent être inférieures à 0 ou supérieures aux constantes fournies Piraterie.MAX X et Piraterie.MAX Y. Les coordonnées que l’on tente donc d’affecter à la
construction ou via d’autre méthodes devront être plafonnées à ces valeurs;
2. La classe doit être bien encapsulée.
Les sous-classes Pirate et Marchand (24 points) Vous ferez ensuite en sorte que la classe Navire
se spécialise en deux sous-classes: les navires pirate (classe Pirate) et les navires marchands (classe
Marchand).
Les navires pirates peuvent être endommagés avant d’être détruits (un booléen servira à indiquer s’ils
sont endommagés). L’initialisation de cet attribut se fera au moyen d’une valeur passée en paramètre.
La hiérarchie de classes sera dotée :
– de constructeurs conformes à la méthode main fournie;
– d’une méthode polymorphique String getName() retournant le nom générique du navire: "Bateau"
dans le cas de la super-classe, "Bateau pirate" pour les navires pirates et "Bateau marchand pour
les navires marchand;
– de la redéfinition de la méthode toString permettant d’afficher un navire en indiquant son nom
générique, son drapeau, ses coordonnées et son état (coulé, intact ou endommagé).
Pour simuler le jeu de bataille navale, on adopte le critère suivant :
Si deux navires sont ennemis (ont des drapeaux différents) et que la distance les séparant est inférieure
à Piraterie.MEETING RADIUS ils se confrontent, sinon rien ne se passe.
Il
–
–
–
vous est donc demandé de doter la hiérarchie d’une méthode meet qui va :
tester si un navire est suffisamment proche d’un autre;
s’ils ont des drapeaux différents;
et dans ce cas faire se confronter les deux navires (méthode fight)
Les règles de confrontation sont les suivantes:
1. si un navire pirate b1 se confronte à un autre navire b2 : b2 reçoit une attaque (méthode bombed).
b1 reçoit aussi une attaque si b2 est un navire pirate;
2. dans tous les autres cas rien ne se passe;
3. un navire marchand qui reçoit une attaque est coulé;
Exemples d’affichage:
Bateau
ou
Bateau
ou
Bateau
ou
Bateau
Bateau
2) Mauvaises rencontres (classe abstraite, polymorphisme, 25 points)
4. un navire pirate non endommagé qui reçoit une attaque est endommagé;
pirate avec drapeau 1 en (100,100): intact
pirate avec drapeau 2 en (100,100): endommagé
5. un navire pirate endommagé qui reçoit une attaque est coulé.
Il vous est demandé de programmer les méthodes suggérées en respecterant les contraintes suivantes:
pirate avec drapeau 3 en (100,100): coulé
1. la hiérarchie de classes comportera une méthode polymorphique bool isPeaceful() retournant
vrai pour navire marchand et faux sinon. Cette méthode sera utilisée pour mettre en oeuvre les
traitements décrits.
marchand
marchand
2. le prototype de la méthode meet sera conforme à la méthode main fournie (une fois la portion de
code entre // TEST 2 et // FIN TEST 2 décommentée);
avec drapeau 1 en
avec drapeau 3 en
(100,100): coulé
(100,100): intact
Pour tester le programme implémenté jusqu’ici, décommentez la partie du programme principal comprise
entre // TEST 1 et // FIN TEST 1.
3. vous considérerez que les méthodes fight et bombed ne peuvent être définies concrètement pour
un navire quelconque.
La trace d’exécution pour cette partie devrait ressembler à ce qui suit :
Pour tester le programme implémenté jusqu’ici, décommentez la partie du programme principal comprise
entre // TEST 2 et // FIN TEST 2.
***Test de la partie 1***
La trace d’exécution pour cette partie devrait ressembler à ce qui suit :
Bateau pirate avec drapeau 1 en (0,0): endommagé
Bateau marchand avec drapeau 2 en (25,0): intact
Distance: 25.0
Quelques d’eplacements horizontaux et verticaux
Bateau pirate avec drapeau 1 en (75,100): endommagé
Bateau marchand avec drapeau 2 en (25,0): intact
Un d’eplacement en bas:
Bateau pirate avec drapeau 1 en (75,95): endommagé
Apres destruction:
Bateau pirate avec drapeau 1 en (75,95): coulé
Bateau marchand avec drapeau 2 en (25,0): coulé
***Test de la partie 2***
Bateau pirate et marchand ennemis, trop ’eloign’es:
Bateau pirate avec drapeau 1 en (0,0): intact
Bateau marchand avec drapeau 2 en (0,25): intact
Apres la rencontre:
Bateau pirate avec drapeau 1 en (0,0): intact
Bateau marchand avec drapeau 2 en (0,25): intact
Bateau pirate et marchand ennemis (proches):
Bateau pirate avec drapeau 1 en (0,0): intact
Bateau marchand avec drapeau 2 en (2,0): intact
Apres la rencontre:
Bateau pirate avec drapeau 1 en (0,0): intact
Bateau marchand avec drapeau 2 en (2,0): coulé
Bateau pirate et marchand amis (proches):
Bateau pirate avec drapeau 1 en (0,0): intact
Bateau marchand avec drapeau 1 en (2,0): intact
Apres la rencontre:
Bateau pirate avec drapeau 1 en (0,0): intact
Bateau marchand avec drapeau 1 en (2,0): intact
Deux bateaux pirates ennemis
Bateau pirate avec drapeau 1
Bateau pirate avec drapeau 2
Apres la rencontre:
Bateau pirate avec drapeau 1
Bateau pirate avec drapeau 2
Un bateau pirate intact et
Bateau pirate avec drapeau
Bateau pirate avec drapeau
Apres la rencontre:
Bateau pirate avec drapeau
Bateau pirate avec drapeau
intacts (proches):
en (0,0): intact
en (2,0): intact
en (0,0): endommagé
en (2,0): endommagé
un endomag’e ennemis:
1 en (0,0): endommagé
3 en (0,2): intact
1 en (0,0): coulé
3 en (0,2): endommagé
Deux bateaux pirates ennemis
Bateau pirate avec drapeau 2
Bateau pirate avec drapeau 3
Apres la rencontre:
Bateau pirate avec drapeau 2
Bateau pirate avec drapeau 3
endommagés:
en (2,0): endommagé
en (0,2): endommagé
en (2,0): coulé
en (0,2): coulé