Exercice polymorphisme JAVA Tour de carte
Rédigé par GC Team, Publié le 17 Août 2010, Mise à jour le Mercredi, 16 Avril 2025 01:42
Révisions: Comparaison d'une approche procédurale avec une approche orientée objet
But:
|
Révisions: Comparaison d'une approche procédurale avec une approche orientée objet | |||
Thème:
|
Polymorphisme, Récursivité | |||
Fichiers:
|
Arith.java |
Johnny C. est étudiant en première année à l'EPFL. Il doit écrire un programme Java simple permettant d'évaluer des expressions arithmétiques. Ces expressions sont constituées de nombres, d'additions et de multiplications; comme ceci :
2 + 5 * 3
Johnny n'a pas encore très bien absorbé les concepts orientés objets permis par Java et il produit la solution suivante :
Arith.java
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 |
/** Structure de donnee pour les expressions*/ class Expression { public int type; public int value; public Expression leftOp; public Expression rightOp; public Expression(int type, int value, Expression leftOp, Expression rightOp) { this.type = type; this.value = value; this.leftOp = leftOp; this.rightOp = rightOp; } } /** Classe principale */ class Arith { /** Constantes pour representer les types*/ public static final int TYPE_NUMBER = 1; public static final int TYPE_SUM = 2; public static final int TYPE_PROD = 3; public static void main(String [] args) { // construit l'expression 3 + 2 * 5 Expression term = new Expression(TYPE_SUM, 0, new Expression(TYPE_NUMBER, 3, null, null), new Expression(TYPE_PROD, 0, new Expression(TYPE_NUMBER, 2, null, null), new Expression(TYPE_NUMBER, 5, null, null))); System.out.println(evaluate(term)); } /** Evalue recursivement l'expression */ public static int evaluate(Expression term) { switch (term.type) { case TYPE_NUMBER: return term.value; case TYPE_SUM: return evaluate(term.leftOp) + evaluate(term.rightOp); case TYPE_PROD: return evaluate(term.leftOp) * evaluate(term.rightOp); default: return 0; //erreur, ne devrait jamais se produire } } } |
Le programme de Johnny fonctionne, mais est écrit dans un style "procédural" plutôt qu'orienté objet. Il peut donc, à cet égard, être amélioré.
- Réflechissez à la solution de Johnny et essayez d'expliquer pourquoi elle n'est pas très bonne et comment elle pourrait être améliorée.
- Ecrivez une version améliorée (commencez par lire l'intégralité des recommandations avant de commencer à programmer) :
- Définissez une classe abstraite Expression qui déclarera une méthode abstraite evaluate.
- Créez des classes distinctes pour chaque type d'expressions (Number, Sum, Product) et faites les hériter de Expression.
- Vous pouvez éviter de la duplication inutile de code en créeant une classe abstraite intermédiaire BinOp qui contiendra les attributs leftOp et rightOp représentants respectivement les opérandes gauche et droit d'un expression binaire. Faites hériter Sum et Product de Binop.
- Adaptez la méthode main de la classe principale à votre nouvelle structure.
- Pour comparer la solution originale de Johnny à la votre, faites évoluer votre programme dans le sens suivant :
- Ajouter la possibilité de générer la représentation de votre expression sous la forme d'une chaîne de caractère. Par exemple si votre expression est le nombre 13, cette fonctionalité doit vous retourner la chaîne "13". Si c'est une Sum avec 12 et 13 comme leftOp et rightOp respectivement, la fonctionalité en question devra retourner la chaîne "12 * 13".
- Ajouter un nouveau type d'expression binaire : Modulo représentant des expressions binaires dont l'évaluation retourne le reste de la division entière de leftOp par rightOp.
Portez un regard critique à votre nouvelle version. Si vous avez dû faire du "copier-coller" de portions de votre code pour ajouter ces facilités, c'est qu'il y a encore des problèmes de conception. Essayer de faire en sorte qu'il n'y ait aucune duplication inutile de code.
Une fois satisfait de votre version, essayez d'ajouter les mêmes facilités au programme de Johnny.
Laquelle des deux versions a été la plus facile à modifier ?
Note : cet exercice a essentiellement pour but d'illustrer l'intérêt du polymorphisme. Afin de nous concentrer sur cet aspect nous nous autoriserons quelques "entorses" au principe d'une bonne encapsulation (privacité des attributs). Une fois que vous aurez réussi à produire une solution polymorphique et à en dégager l'intérêt par rapport au code d'origine, le soin vous est laissé de parfaire votre code en vous concentrant cette fois sur son encapsulation.
Le programme de Johnny fonctionne, mais est écrit dans un style "procédural" plutôt qu'orienté objet. Il peut donc, à cet égard, être amélioré.
- Réflechissez à la solution de Johnny et essayez d'expliquer pourquoi elle n'est pas très bonne et comment elle pourrait être améliorée.
- Ecrivez une version améliorée (commencez par lire l'intégralité des recommandations avant de commencer à programmer) :
- Définissez une classe abstraite Expression qui déclarera une méthode abstraite evaluate.
- Créez des classes distinctes pour chaque type d'expressions (Number, Sum, Product) et faites les hériter de Expression.
- Vous pouvez éviter de la duplication inutile de code en créeant une classe abstraite intermédiaire BinOp qui contiendra les attributs leftOp et rightOp représentants respectivement les opérandes gauche et droit d'un expression binaire. Faites hériter Sum et Product de Binop.
- Adaptez la méthode main de la classe principale à votre nouvelle structure.
- Pour comparer la solution originale de Johnny à la votre, faites évoluer votre programme dans le sens suivant :
- Ajouter la possibilité de générer la représentation de votre expression sous la forme d'une chaîne de caractère. Par exemple si votre expression est le nombre 13, cette fonctionalité doit vous retourner la chaîne "13". Si c'est une Sum avec 12 et 13 comme leftOp et rightOp respectivement, la fonctionalité en question devra retourner la chaîne "12 * 13".
- Ajouter un nouveau type d'expression binaire : Modulo représentant des expressions binaires dont l'évaluation retourne le reste de la division entière de leftOp par rightOp.
Portez un regard critique à votre nouvelle version. Si vous avez dû faire du "copier-coller" de portions de votre code pour ajouter ces facilités, c'est qu'il y a encore des problèmes de conception. Essayer de faire en sorte qu'il n'y ait aucune duplication inutile de code.
Une fois satisfait de votre version, essayez d'ajouter les mêmes facilités au programme de Johnny.
Laquelle des deux versions a été la plus facile à modifier ?
Note : cet exercice a essentiellement pour but d'illustrer l'intérêt du polymorphisme. Afin de nous concentrer sur cet aspect nous nous autoriserons quelques "entorses" au principe d'une bonne encapsulation (privacité des attributs). Une fois que vous aurez réussi à produire une solution polymorphique et à en dégager l'intérêt par rapport au code d'origine, le soin vous est laissé de parfaire votre code en vous concentrant cette fois sur son encapsulation.
Décrire les données d'un jeu simulant des combats de magiciens
But:
|
||||
Thème:
|
polymorphisme | |||
Fichiers:
|
Magic.java |
Vous vous intéressez dans cet exercice à décrire les données d'un jeu simulant des combats de magiciens.
Dans ce jeu, il existe trois types de cartes : les terrains, les créatures et les sortilèges.
- Les terrains possèdent une couleur (parmi 5 : blanc('B'), bleu ('b'), noir ('n'), rouge ('r') et vert ('v').)
- Les créatures possèdent un nom, un nombre de points de dégâts et un nombre de points de vie.
- Les sortilèges possèdent un nom et une explication sous forme de texte.
De plus, chaque carte, indépendamment de son type, possède un coût. Celui d'un terrain est 0.
Dans un programme Magic.java, proposez (et implémentez) une hiérarchie de classes permettant de représenter des cartes de différents types.
Chaque classe aura un constructeur permettant de spécifier la/les valeurs de ses attributs. De plus, chaque constructeur devra afficher le type de la carte.
Le programme doit utiliser la conception orientée objet et ne doit pas comporter de duplication de code.
Ajoutez ensuite aux cartes une méthode afficher() qui, pour toute carte, affiche son coût et la valeur de ses arguments spécifiques.
Créez de plus une classe Jeu pour représenter un jeu de cartes, c'est-à-dire une collection de telles cartes.
Cette classe devra avoir une méthode piocher permettant d'ajouter une carte au jeu. On supposera qu'un jeu comporte au plus 10 cartes. Le jeu comportera également une méthode joue permettant de jouer une carte. Pour simplifier, on jouera les cartes dans l'ordre où elles sont stockées dans le jeu, et on mettra la carte jouée à null dans le jeu de cartes.
Pour finir, dans la méthode main, constituez un jeu contenant divers types de cartes et faites afficher le jeu grâce à une méthode afficher propre à cette classe.
Par exemple la méthode main pourrait ressembler à quelque chose comme cela :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
class Magic { public static void main(String[] args) { Jeu maMain = new Jeu(10); maMain.piocher(new Terrain('b')); maMain.piocher(new Creature(6, "Golem", 4, 6)); maMain.piocher(new Sortilege(1, "Croissance Gigantesque", "La créature ciblée gagne +3/+3 jusqu'à la fin du tour")); System.out.println("Là, j'ai en stock :"); maMain.afficher(); maMain.joue(); } } |
qui produirait quelque chose comme :
On change de main Un nouveau terrain. Une nouvelle créature. Un sortilège de plus. Là, j'ai en stock : Un terrain bleu Une créature Golem 4/6 Un sortilège Croissance Gigantesque Je joue une carte... La carte jouée est : Un terrain bleu
Fichiers:
|
Magic.java |
Le code complet vous est donné ci-dessous:
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 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 |
/** * Une petite classe utilitaire pour commencer */ class Couleur { private char valeur; public Couleur(char c) { valeur = c; } public void afficher() { this.afficher(false); } public void afficher(boolean feminin) { switch (valeur) { case 'r': System.out.println("rouge"); break; case 'v': System.out.print("vert"); if (feminin) { System.out.println("e"); } break; case 'b': System.out.print("bleu"); if (feminin) { System.out.println("e"); } break; case 'B': System.out.print("blanc"); if (feminin) { System.out.println("he"); } break; case 'n': System.out.print("noir"); if (feminin) { System.out.println("e"); } break; } } } // ---------------------------------------------------------------------- // puis.. les classes principales abstract class Carte { private int cout; public Carte() { cout = 0; } public Carte(int cout) { this.cout = cout; } public abstract void afficher(); } // ---------------------------------------------------------------------- class Terrain extends Carte { private Couleur couleur; public Terrain(char c) { couleur = new Couleur(c); System.out.println("Un nouveau terrain."); } public void afficher() { System.out.print("Un terrain "); couleur.afficher(); System.out.println(); } } // ---------------------------------------------------------------------- class Creature extends Carte { private String nom; private int attaque; private int defense; public Creature(int cout, String nom, int attaque, int defense) { super(cout); this.nom = nom; this.attaque = attaque; this.defense = defense; System.out.println("Une nouvelle créature."); } public void afficher() { System.out.println("Une créature " + nom + " " + attaque + "/" + defense + " "); } } // ---------------------------------------------------------------------- class Sortilege extends Carte { private String nom; private String description; public Sortilege(int cout, String nom, String desc) { super(cout); this.nom = nom; this.description = desc; System.out.println("Un sortilège de plus."); } public void afficher() { System.out.println("Un sortilège " + nom + " "); } } // ---------------------------------------------------------------------- class Jeu { private int nombreCartes; private Carte[] cartes; public Jeu(int nb) { nombreCartes = nb; cartes = new Carte[nb]; System.out.println("On change de main"); } /** * Joue une carte après l'autre */ public void joue() { System.out.println("Je joue une carte..."); int i = 0; while ((cartes[i] == null) && i < nombreCartes) { i++; } if ((i < nombreCartes) && (cartes[i] != null)) { System.out.println("La carte jouée est :"); cartes[i].afficher(); cartes[i] = null; } else { System.out.println("Plus de cartes"); } } /** * Ajoute une carte à la collection */ public void piocher(Carte carte) { int i = 0; while ((i < nombreCartes) && (cartes[i] != null)) { i++; } if (i < nombreCartes) { cartes[i] = carte; } else { System.out.println("Nombre maximal de cartes atteint"); } } public void afficher() { for (int i = 0; i < nombreCartes; ++i) { if (cartes[i] != null) { cartes[i].afficher(); } } } } // ---------------------------------------------------------------------- class Magic { public static void main(String[] args) { Jeu maMain = new Jeu(10); maMain.piocher(new Terrain('b')); maMain.piocher(new Creature(6, "Golem", 4, 6)); maMain.piocher(new Sortilege(1, "Croissance Gigantesque", "La créature ciblée gagne +3/+3 jusqu'à la fin du tour")); System.out.println("Là, j'ai en stock :"); maMain.afficher(); maMain.joue(); } } |