Patrons de conception dans un concours de mangeurs de galettes

Ce TP propose de manipuler des patrons de conception dans le cadre d’un concours de mangeurs de galettes. Il permet de comprendre et d’appliquer les patrons Fabrique Abstraite et Stratégie, ainsi que d’intégrer les principes SOLID dans la conception logicielle. Pour réaliser ce TP, il est nécessaire d’avoir déjà conçu une application simulant un concours de mangeurs de galettes et de posséder des connaissances en programmation orientée objet.

Objectifs

• Manipuler les patrons de conception Fabrique Abstraite et Stratégie
• Comprendre et appliquer le principe SOLID

Prérequis et mise en place

• Connaissance préalable du concours de mangeurs de galettes et de sa modélisation initiale
• Application de base simulant un concours avec les classes MangeurDeGalettes, Gourmand, Gourmet et Concours
• Environnement de développement permettant d’écrire et tester du code orienté objet

Reprise de l’exercice du concours de galettes

Dans cet exercice, vous devez reprendre la conception initiale du concours de mangeurs de galettes. Le concours se déroule ainsi :

• Chaque mangeur prend une part à son tour et la mange.
• Si un mangeur trouve la fève, le concours s’arrête et il est déclaré vainqueur.
• Si un mangeur dépasse son poids maximum autorisé de galette mangée, il ne peut plus continuer.
• Le concours s’arrête lorsqu’il n’y a plus de mangeurs capables de continuer ou qu’un gagnant est trouvé.

La classe MangeurDeGalettes est caractérisée par :

• Un poids maximum de galette qu’il peut manger
• Le poids de galette effectivement mangé
• La possession éventuelle de la fève
• Une méthode mangerPart(PartDeGalette part) pour manger une part
• Une méthode rechercherParts(...) pour rechercher la prochaine part à manger

Deux spécialisations existent :

• Gourmand : peut manger jusqu’à 2 kg de galettes et cherche les plus grosses parts en premier
• Gourmet : peut manger jusqu’à 500 g de galettes et cherche les plus petites parts en premier

La classe Concours contient :

• Une collection de mangeurs de galettes
• Une collection de galettes
• Trois méthodes principales :
• nettoyerTable() : supprime les galettes ne contenant plus de parts à manger
• enleverLesPerdants() : supprime les mangeurs qui ne peuvent plus manger
• concourir() : fait dérouler le concours et renvoie le gagnant ou null si personne ne trouve la fève

Consignes :

• Réalisez le diagramme de classes correspondant à votre solution
• Analysez si votre solution respecte les principes SOLID et modifiez-la pour maximiser leur respect
• Écrivez les tests unitaires nécessaires pour valider votre solution

Extension avec le patron Fabrique Abstraite

Pour étendre le programme, il faut maintenant gérer plusieurs types de galettes :

• Galette à la frangipane (~2 kg pour 8 parts)
• Galette à la pistache (~2,5 kg pour 8 parts)
• Galette allégée (~500 g pour 8 parts)

Pour cela, vous devez :

• Étendre votre diagramme de classes pour intégrer cette extension
• Utiliser le patron Fabrique Abstraite afin de créer facilement différentes galettes pour les concours
• Vérifier que la solution reste évolutive en ajoutant une nouvelle recette de galette végane (~1,5 kg pour 8 parts)

Cette étape permet de séparer la création des objets galettes de leur utilisation, facilitant ainsi l’ajout de nouvelles variétés sans modifier le code existant.

Introduction du patron Stratégie

Initialement, les classes Gourmand et Gourmet étaient définies par héritage. Cette approche ne respecte pas le principe O de SOLID (Ouvert/Fermé). Pour améliorer cela :

• Modifiez votre conception pour introduire un patron de Stratégie permettant de représenter les comportements des mangeurs
• Adaptez les stratégies en fonction des types de galettes :
• Le gourmand vise les galettes à la pistache
• Le gourmet se concentre sur les galettes à la frangipane
• Ajoutez un nouveau type de compétiteur : le Vegan, qui ne mange que des galettes véganes

Cette modification permet de changer dynamiquement la stratégie de sélection des parts sans modifier la classe MangeurDeGalettes elle-même, améliorant ainsi la flexibilité et la maintenabilité du code.

Résultats attendus

• Une application fonctionnelle simulant un concours de mangeurs de galettes avec différents types de mangeurs et galettes
• Respect des principes SOLID dans la conception
• Utilisation correcte des patrons Fabrique Abstraite et Stratégie
• Possibilité d’ajouter facilement de nouvelles galettes ou stratégies sans modifier le code existant
• Tests unitaires validant le comportement des classes et des stratégies

Pièges courants

• Ne pas respecter les principes SOLID, notamment le principe O (Ouvert/Fermé), en modifiant directement les classes existantes pour ajouter des comportements
• Confondre la responsabilité des classes, par exemple en mélangeant la logique de création des galettes avec la logique métier
• Oublier de mettre à jour les tests unitaires après modification de la conception
• Ne pas vérifier que les stratégies correspondent bien aux types de galettes lors de l’introduction du patron Stratégie
• Ne pas nettoyer correctement les collections dans la classe Concours, ce qui peut entraîner des erreurs lors du déroulement du concours