Les patterns

Structure d'un pattern

Le langage de “pattern”¹ est défini par la structure suivante :

• nom du “pattern”¹ : le nom d'un “pattern”¹ permet tout d'abord de faciliter la communication en nous permettant d'identifier précisément une situation lors du développement d'applications, sans que notre interlocuteur ne doive maîtriser le même langage de programmation que nous. Nous pouvons atteindre un haut degré d'abstraction en utilisant le nom correct du “pattern”¹, sans devoir évoquer la moindre ligne de code.
• problème : le problème, ou contexte, décrit dans quelle situation le “pattern”¹ peut nous aider. Souvent, les conditions du problème sont ajoutées à sa description.
• solution : la solution ne décrit pas des éléments concrets de "design"⁷ ou des implémentations précises. Il s'agit d'un modèle qu'il est possible d'appliquer à de nombreuses situations différentes, mais qui toutes amènent au problème décrit.
• conséquences du “pattern”¹ : les conséquences permettent d'évaluer les coûts et bénéfices des différentes alternatives possibles.

Catalogue des 23 patterns du GOF

• “Creational Patterns” (en français, « motifs de création ») :
  • “Abstract Factory” (en français, « fabrique abstraite ») : permet un point d'accès à la création de familles d'objets liés entre eux ou dépendant les uns des autres, indépendament de leurs classes concrètes.
  • “Builder” (en français, « constructeur ») : permet de séparer la construction d'un objet complexe de sa représentation, de telle manière que le même processus de construction puisse différentes représentations.
  • “Factory Method” (en français, « fabrique ») : permet un point d'accès à la création d'objets tout en laissant aux sous-classes le soin de la sélection de la classe qui devra être instanciée.
  • “Prototype” (en français, « prototype ») : permet de spécifier le type d'objets à créer en utilisant une instance prototype. Le prototype sera copié pour créer les nouveaux objets.
  • “Singleton” (en français, « instance unique ») : permet de nous assurer qu'une seule instance d'un objet sera créée, et de nous fournir un point d'accès vers ce dernier.
• “Structural Patterns” (en français, « motifs de structure ») :
  • “Adapter” (en français, « adaptateur ») : permet d'adapter par encapsulatrion les signatures de methodes d'une classe vers une autre.
  • “Bridge” (en français, « pont ») : permet de différencier une abstraction de son implémentation, permettant à chacune d'évoluer indépendamment.
  • “Composite” (en français, « objet composite ») : permet de traiter une structure d'objets de manière uniforme.
  • “Decorator” (en français, « décorateur ») : permet de créer une classe qui étend les capacités d'une ou de plusieurs classes.
  • “Facade” (en français, « façade ») : nous facilite l'usage d'un sous-système, en définissant une interface de haut niveau qui unifie les interfaces du sous-système.
  • “Flyweight” (en français, « poids-mouche, ou poids-plume ») : partage des éléments nécessaires à un grand nombre d'objets, ce qui évite de les maintenir en duplicats dans les différents objets qui en ont besoin.
  • “Proxy” (en français, « procuration, substitut ») : oblige les appels des méthodes d'un objet à passer par un objet (“proxy”²¹) qui agit comme un substitut pour l'autre objet, déléguant les appels de méthodes à cet objet. Les classes sont créées de telle sorte que l'objet client ne peut voir qu'il travaille avec un “proxy”²¹.
• “Behavioral Patterns” (en français, « motifs de comportement ») :
  • “Chain of Responsibility” (en français, « chaîne de responsabilité ») : permet un plus faible couplage dans le cas où un élément est attendu par un grand nombre d'objets, en passant l'élément à un seul objet qui le passe au suivant, et ainsi de suite au long de la chaîne.
  • “Command” (en français, « commande ») : encapsule une requête dans un objet, et permet les files d'attentes, les journalisations , et “undo” (en français, « annulation de la dernière opération »).
  • “Interpreter” (en français, « interpréteur ») : définit un langage ainsi que sa grammaire, et fournit un interpreteur pour utiliser la représentation du langage.
  • “Iterator” (en français, « itérateur ») : fournit un accès aux éléments d'un agrégat d'objets indépendament de la représentation réelle de l'agrégation (le type de tableau, de collection utilisé).
  • “Mediator” (en français, « médiateur ») : définit un objet qui encapsule la manière dont un ensemble d'objets interagissent.
  • “Memento” (en français, « mémento ») : permet, sans violer l'encapsulation, de capturer et d'externaliser l'état interne d'un objet pour le mémoriser afin de le restaurer par la suite si nécessaire.
  • “Observer” (en français, « observateur ») : permet aux objets d'enregistrer dynamiquement les dépendances entre objets, de telle sorte qu'un objet qui change d'état le notifie à tous ceux qui dépendent de lui, sans qu'il ne les connaisse réellement.
  • “State” (en français, « état ») : permet d'altérer le comportement d'un objet en fonction de son état interne.
  • “Strategy” (en français, « stratégie ») : définit une famille d'algorithmes, encapsule chacun d'eux, et les rend interchangeable.
  • “Template Method” (en français, « modèle de méthode ») : définit le squelette d'un algorithme dans une opération, déléguant certaines étapes aux sous-classes. Il permet de redéfinir certaines étapes d'un algorithme sans en changer la structure.
  • “Visitor” (en français, « visiteur ») : permet de séparer un algorithme de la structure d'un objet.

Contents Haut