Skip to topic | Skip to bottom
Home
Minfo
Minfo.GlTD6r1.1 - 11 Nov 2012 - 21:14 - PhilippeCollettopic end

Start of topic | Skip to actions

TD 6 : Patrons de conception

PhilippeCollet

Introduction

Objectif

Dans ce TD, il s'agit de mettre en oeuvre plusieurs aspects de l'utilisation des patrons de conception:

  • La conception à l'aide des patrons, et comment choisir le bon patron (et donc comment éviter d'utiliser le mauvais outil),
  • L'implémentation de plusieurs patrons, afin de bien expérimenter la nécessité de réfléchir à leur mise en oeuvre.

Point de départ

  • Créez un projet pour démarrer ce TD et placez dedans le contenu de l'archive DP.zip.
  • Nous partons du dernier TD d et nous disposons donc d'un ensemble de classes qui effectue un certain nombre d'abstractions sur notre simulateur de bébêtes à l'aide d'interfaces, de classes abstraites et concrètes.
  • ALERT! La classe ChampDeBebetes est légèrement modifiée :
    • elle utilise une méthode initialiseElements pour regrouper la construction des objets nécessaires,
    • la méthode setDessinables a été redéfinie afin de synchroniser automatiquement la liste dans le simulateur (les objets Dessinables qui héritent d'Actionnable sont fournis au simulateur).

Une nouvelle forme d'entité

On souhaite ajouter au simulateur d'autres entités, pas forcément des bébêtes. Dans ce TD, on va ajouter des objets inertes, des champignons, et on va modifier des bébêtes pour qu'elles soient "sensibles" à ces champignons (cela déviera leur trajectoire).

Normalement, les abstractions effectuées dans l'architecture actuelle devraient suffire à intégrer correctement nos champignons :

  • Déterminez comment intégrer une classe Champi dans la hiérarchie.
  • Créez une classe Champi qui définit un champignon par des attributs et méthodes supplémentaires pour gérer une taille (toujours en pixel pour faire simple), une couleur (rouge par défaut pour ne pas avoir a en fixer une lors de la construction).
  • Définissez la méthode d'affichage de Champi pour dessiner un cercle, comme ça par exemple :
    public void seDessine(Graphics g) {
        g.setColor(couleur);
        g.fillOval(x,y,TAILLEGRAPHIQUE,TAILLEGRAPHIQUE);
    }
  • Vérifiez rapidement que votre classe Champi est fonctionnelle en créant un Champi dans le champ et en l'affichant. Compilez, exécutez...

Cohérence du processus de fabrication des entités

On veut maintenant s'assurer que les différentes entités que l'on place dans une simulation sont bien cohérentes entre elles, donc qu'elles sont créées de manière cohérente :

  • Trouvez quel(s) patron(s) de conception sont nécessaires pour réaliser cela.
  • Dans le processus de création des bébêtes dans le champ, étudiez quelles méthodes peuvent être récupérées ou appelées afin de fournir le meilleur service de création.
  • A partir de cela, établissez la liste de ce qu'il faut réaliser (nouvelles classes et/ou interfaces) et de ce qu'il faut modifier dans les classes existantes. Faites valider le tout par l'enseignant avant de vous lancer, car il faut penser à pas mal de choses :
    • Comment initialiser la fabrique ?
    • Comment assurer qu'il n'y a qu'une fabrique par exécution ?
    • Comment créer des fabriques différentes (une pour des bebeteHasard, d'autres pour des bebeteEmergente, etc.) ?
    • Comment assurer au mieux que le code client ne crée pas d'entités sans passer par la fabrique ?
    • Comment le code du lanceur de l'application va utiliser votre fabrique en collaboration avec le champ à créer ?

  • Codez tout ça afin de réaliser la même simulation que dans la question précédente (des bébêtes émergentes et un champignon).
  • Vérifiez que cela fonctionne de la même manière.

Correction: DP-exo2.zip

Création de bébêtes sensibles aux champignons

Il nous faut maintenant ajouter la sensibilité aux champignons à nos bébêtes émergentes :

  • Envisagez de réaliser cette fonctionnalité à partir du pattern Decorator et expliquez pourquoi, sans une refonte importante des classes, il vaut mieux ne pas utiliser ce pattern.
  • Créez une sous-classe de ChampDeBebetes qui va gérer une liste des champignons (aide: inspirez-vous de la fabrication de la liste des bébêtes pour ajoutez a la fabrique une méthode qui crée cette liste de Champi).
  • Quelles méthodes faut-il redéfinir pour appeler la fabrication et afficher les champignons dans cette classe ? Ecrivez-les.
  • Equipez la classe ChampsDeBebetesAvecChampi d'une méthode pour déterminer si une bébête est proche d'un champignon (attention l'extrait suivant dépend des attributs définis dans les classes ChampsDeBebetesAvecChampi et Champi, il faudra sans doute le modifier; vous pouvez aussi utiliser des raccourcis de parcours Java 5) :
    public boolean BebeteSurChampi(Bebete b) {
        ListIterator<? extends Champi> li = lesChampis.listIterator();
        while (li.hasNext()) {
            Champi item = li.next();
            if (DistancesEtDirections.distanceDepuisUnPoint(b.getX(),b.getY(),item.getX(),item.getY())
                     <= (Champi.TAILLEGRAPHIQUE / 2))
                return true;
        }
        return false;
    }
  • Créez par héritage une classe BebeteSensibleChampi qui étend la classe BebeteEmergente :
    • avec un constructeur équivalent qui appelle celui de la superclasse,
    • qui redéfinit la méthode calculeDeplacementAFaire() afin qu'elle utilise la méthode bebeteSurChampi pour déterminer si elle se trouve sur un champignon. Si c'est le cas, il suffit de modifier sa vitesse et sa direction (comme pour la bebete hasard), sinon il suffit d'appeler le calcul de la superclasse :

        if // this est sur un champi...
            directionCourante = (float) ((directionCourante +
                                          ((Math.random() * Math.PI / 2) -
                                           (Math.PI / 4))) % (Math.PI * 2));
            if (directionCourante < 0) {
                directionCourante += (float) (Math.PI * 2);
            }
        } else {
            super.calculeDeplacementAFaire();
        }
    }
  • Modifiez le code de lancement pour créer une nouvelle forme de champ, une cinquante de bébêtes "sensibles" et 5 Champi. Faites tourner la simulation pour constater les déviations de trajectoires.

Amélioration de la fabrique

Avec les deux formes de champs de bébêtes dont nous disposons maintenant, nous sommes de nouveau confrontés au problème de cohérence de la création. Il ne faudrait pas qu'on place des bébêtes sensibles dans un champ qui ne peut détecter leur sensibilité.

  • Que faudrait-il faire pour assurer cette cohérence ?
  • Modifiez les fabriques en conséquence.

Compter le nombre de bébêtes déviées

Pour terminer, on souhaiterait afficher le nombre de bébêtes déviées par des champignons au fur et à mesure que les déviations ont lieu. L'affichage se fera dans un simple JLabel dont on changera le texte :

  • Quel patron faut-il appliquer pour que l'on puisse par la suite associer plusieurs afficheurs différents a chaque fois qu'une déviation a lieu ?
  • Appliquez ce patron.
  • ALERT! Si vous avez besoin d'hériter d'une classe abstraite fournissant du code dans la classe Bebete, il vous faudra sans doute modifier la hiérarchie d'héritage : le mieux est alors de transformer PerceptionAble en interface et de déplacer le code de détection des choses vues dans la classe Utilitaire.

-- PhilippeCollet - 11 Nov 2012
to top

I Attachment sort Action Size down Date Who Comment
DP-exo2.zip manage 13.4 K 11 Nov 2012 - 22:18 PhilippeCollet  
DP.zip manage 9.9 K 11 Nov 2012 - 22:17 PhilippeCollet  

You are here: Minfo > GlTD6

to top

Copyright © 1999-2017 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding WIKIDeptinfo? Send feedback