Académique Documents
Professionnel Documents
Culture Documents
DESIGN PATTERN
Un art difficile...
Une conception réutilisable, extensible, adaptable,
performante extrêmement difficile.
Quelle est la différence entre un novice et un
concepteur expérimenté
le novice hésite beaucoup entre différentes variantes
l’expert trouve tout de suite la bonne solution.
1
20/10/2020
L’expérience c’est
ne pas réinventer la roue,
réutiliser systématiquement des solutions qui ont fait leurs
preuves,
pour une conception modulaire, élégante, adaptable
répétition de certains profils de classes ou
collaboration d’objets
lesdesign patterns
= modèles de conception
= patrons de conception
Définition
4
Un pattern est une bonne pratique face à un problème courant.
Un pattern est une capitalisation du savoir-faire et de l’expérience
pour résoudre des problèmes récurrents intervenants dans les
différents niveaux du processus:
analyse (analysis pattern),
architecture (architectural pattern)
conception (design pattern)
programmation (idiomes ou idiomatiques en français)
2
20/10/2020
Définition
5
Objectifs
6
Modularité
Facilité de gestion (technologie objet)
Cohésion
Degré avec lequel les tâches réalisées par un seul module
sont fonctionnellement reliées
Une forte cohésion est une bonne qualité
Couplage
Degré d’interaction entre les modules dans le système
Un couplage faible est une bonne qualité
Réutilisabilité
Bibliothèques, frameworks (cadres)
3
20/10/2020
4
20/10/2020
Exemple : couplage
9
10
5
20/10/2020
Ouvrage de référence
11
Très célèbres
conçus par 4 informaticiens : Erich Gamma, Richard
Helm, Ralph Johnson et John Vlissides, surnommés le
”Gang of Four” (GoF)
Ils proposent des solutions élégantes, pour résoudre
différents problèmes récurrents rencontrés par les
architectes logiciels.
Le catalogue GoF patterns (23 patterns)
6
20/10/2020
Création
Description de la manière dont un objet ou un ensemble
d’objets peuvent être créés, initialisés, et configurés
Singleton
Monteur (builder)
Prototype (Prototype )
Structure
Description de la manière dont doivent être connectés des objets
de l’application afin de rendre ces connections indépendantes
des évolutions futures de l’application
Découplage de l’interface et de l’implémentation de classes et
d’objets
Adaptateur (Adapter) ,
Pont (Bridge) ,
Objet composite (Composite),
Décorateur (Decorator) ,
Façade (Facade) ,
Poids-mouche ou poids-plume (Flyweight) ,
Proxy (Proxy)
7
20/10/2020
Comportement
Description de comportements d’interaction entre objets
Gestion des interactions dynamiques entre des classes et des
objets
Chaîne de responsabilité (Chain of responsibility),
Commande (Command) ,
Interpréteur (Interpreter)
Itérateur (Iterator),
Médiateur (Mediator)
Memento (Memento)
Observateur (Observer)
État (State)
Stratégie (Strategy)
Patron de méthode (Template Method)
Visiteur (Visitor)
8
27/10/2020
Patron de conception
Singleton : présentation
2
Intention
S’assurer qu’une classe a une seule instance, et fournir un point
d’accès global à celle-ci.
Exemple
Un seul window manager, un seul point d’accès à une base de
données, un seul pilote de périphérique (instancier plus qu’une fois
surcharge inutile, comportement incohérent)
Comment créer une classe utilisée plusieurs fois dans une
application mais instanciée une seule fois?
Solution
Le Singleton va permettre de récupérer l'objet unique, sans se soucier de
vérifier si il existe déjà ou pas
rendre le constructeur de la classe privée.
méthode statique qui retournera un objet correspondant au type de la
classe
1
27/10/2020
Singleton: Diagramme
3
Singleton : implémentation
4
public class Singleton {
/** Création de l'instance au niveau de la variable statique. */
private static Singleton INSTANCE = null;
/**La présence d'un constructeur privé supprime
* le constructeur public par défaut. */
private Singleton() {}
/**Retourne l'instance du singleton. */
public static Singleton getInstance() {
If(INSTANCE ==null) {
INSTANCE =new Singleton()
}
return INSTANCE;
}
/** A partir d'ici, toutes les méthodes de l'instance (non statique)
*/
}
2
27/10/2020
Patron de conception
Intention
Définit une classe pour la création d’un objet, mais en laissant à
des sous-classes le choix des classes à instancier
Permet la délégation d’instanciation
Exemple
Instancier des classes, en connaissant uniquement les classes
abstraites.
Framework pour des applications qui présentent des
documents multiples à l’utilisateur
3
27/10/2020
Patron de conception
Patron de conception
4
27/10/2020
Patron de conception
Conséquence :
La fabrication dispense d’avoir à incorporer à son code
des classes spécifiques de l’application. Le code ne
concerne que l’interface Product, il peut donc fonctionner
avec toute classe ConcreteProduct définie par
l’utilisateur
La création d’objets à l’intérieur d’une classe avec la
méthode fabrication est toujours plus flexible que la
création d’un objet directement
Exemple
10
5
27/10/2020
Patron de conception
Implémentation (2 possibilités)
La classe Creator est une classe abstraite et ne fournit pas
d’implémentation
La classe Creator est une classe concrète qui fournit une
implémentation par défaut pour la fabrication
Fabrication paramétrée
Utilisation de paramètres pour déterminer la variété d’objet
Exemple : fabrique de documents, choix d’objet en fonction
de dimensions, etc.
Patron de conception
Intention
Le pattern abstract factory fournit une interface pour la
création de familles d'objets apparentés ou indépendants
sans devoir spécifier leurs classes concrètes.
Exemple:
une boite à outils qui supporte de multiples apparences :
motif et présentation Manager : pour qu’une application soit
portable indépendamment de l’apparence utilisée les widgets
ne doivent pas être codés en dur
6
27/10/2020
13
Patron de conception
Champs d’application
Indépendance de comment les objets/produits sont créés,
composés et représentés
Configuration d’un système par une instance d’une multitude
de familles de produits
Conception d’une famille d’objets pour être utilisés ensemble
et contrôle de cette contrainte
Bibliothèque fournie avec seulement leurs interfaces, pas leurs
implémentations
(bibliothèque graphique, look-and-feel)
7
27/10/2020
Patron de conception
Patron de conception
Structure
La fabrique
AbstractFactory déclare l’interface pour les opérations qui créent des
objets abstraits
ConcreteFactory implémente les opérations qui créent les objets concrets
Les objets (plusieurs types)
AbstractProduct déclare une interface pour un type d’objet
ConcreteProduct définit un objet qui doit être créé par la fabrique
concrète correspondante et implémente l’interface AbstractProduct
L’utilisateur
Client utilise seulement les interfaces déclarée par AbstractFactory et par
les classes AbstractProduct
8
27/10/2020
Patron de conception
Collaborations
Normalement, une seule instance de fabrique concrète
est créée à l’exécution. Cette fabrique crée les objets
avec une implémentation spécifique. Pour créer
différents sortes d’objets, les clients doivent utiliser
différentes fabriques concrètes.
La fabrique abstraite défère la création des objets à ses
sous-classes concrètes
Patron de conception
Conséquences
Isolationdes classes concrètes (seules les classes
abstraites sont connues)
Échange facile des familles de produit
9
27/10/2020
Patron de conception
Implémentation
Les fabriques sont souvent des singletons
Ce sont les sous-classes concrètes qui font la création, en
utilisant le plus souvent une Factory Method
20
10
27/10/2020
21
22
11
27/10/2020
23
24
12
27/10/2020
25
26
13
27/10/2020
27
28
14
27/10/2020
29
Patron de conception
Builder : présentation
30
Intention
Séparer la construction d’un objet complexe de sa représentation, de
sorte que le même processus de construction adapte la représentation
selon les objets
Exemple
Dans un carnet d’adresse, traiter de la même façon les personnes et les
groupes
Manipuler ensemble des objets « proches » (générateur d’interface le cas
des différentes fenêtres d'une IHM. Elles comportent des éléments
similaires (titre, boutons), mais chacune avec des particularités (libellés,
comportements)
15
27/10/2020
Builder: diagramme
31
Builder: structure
32
Structure
ObjetComplexe : est la classe d'objet complexe à instancier.
Monteur : définit l'interface des méthodes permettant de créer les différentes parties
de l'objet complexe.
ConcreteMonteurA et ConcreteMonteurB : implémentent les méthodes permettant de
créer les différentes parties. Les classes conservent l'objet durant sa construction et
fournissent un moyen de récupérer le résultat de la construction.
Directeur : construit un objet en appelant les méthodes d'un Monteur.
La partie cliente instancie un Monteur. Elle le fournit au Directeur. Elle appelle la
méthode de contruction du Directeur.
Conséquences
La représentations internes d’un objet peut varier.
La modularité : les builders sont indépendants
16
27/10/2020
Modèle
33
Exemple
34
17
27/10/2020
Application
35
Implémentation Java
36
//Abstract Builder
class abstract class TextConverter{
abstract void convertCharacter(char c);
abstract void convertParagraph();
}
// Product
class ASCIIText{
public void append(char c){ //Implement the code
here }
}
18
27/10/2020
//Concrete Builder
class ASCIIConverter extends TextConverter{
ASCIIText asciiTextObj;//resulting product
37
38
19
27/10/2020
//Director
class RTFReader{
private static final char EOF='0'; //Delimitor for End of File
final char CHAR='c';
final char PARA='p';
char t;
TextConverter builder;
RTFReader(TextConverter obj){
builder=obj;
}
void parseRTF(Document doc){
while ((t=doc.getNextToken())!= EOF){
switch (t){
case CHAR: builder.convertCharacter(t);
case PARA: builder.convertParagraph();
}
}
}
}
39
//Client
public class Client{
void createASCIIText(Document doc){
ASCIIConverter asciiBuilder = new ASCIIConverter();
RTFReader rtfReader = new RTFReader(asciiBuilder);
rtfReader.parseRTF(doc);
ASCIIText asciiText = asciiBuilder.getResult();
}
public static void main(String args[]){
Client client=new Client();
Document doc=new Document();
client.createASCIIText(doc);
system.out.println("This is an example of Builder Pattern");
}
}
40
20
27/10/2020
21
27/10/2020
22
27/10/2020
Patron de conception
Prototype
46
Intention
Dupliquer (cloner) un objet trop coûteux à créer
Créer des objets différents uniquement par le comportement. Le
prototype sert de modèle.
Exemple
Le système doit créer de nouvelles instances, mais il ignore de quelle classe. Il
dispose cependant d'instances de la classe désirée.
Cela peut être le cas d'un logiciel de DAO comportant un copier-coller.
L'utilisateur sélectionne un élément graphique (cercle, rectangle, ...), mais la
classe traitant la demande de copier-coller ne connaît pas la classe exacte
de l'élément à copier.
La solution est de disposer d'une duplication des instances (élément à copier :
cercle, rectangle). La duplication peut être également intéressante pour les
performances (la duplication est plus rapide que l'instanciation).
23
27/10/2020
Prototype: diagramme
47
Prototype
48
Structure
Prototype : définit l'interface de duplication de soi-même.
ConcretePrototypeA et ConcretePrototypeB : sont des sous-
classes concrètes de Prototype. Elles implémentent l'inteface
de duplication.
La partie cliente appelle la méthode clone() de la classe
Prototype. Cette méthode retourne un double de l'instance.
Conséquences
Création d’instances « différentes » sans créer de classe
24
17/11/2020
Adaptateur
Le pattern Adaptateur permet de transformer une
interface d'une classe en une autre conforme à celle
attendue par le client. L'adaptateur permet à des
classes de collaborer alors qu'elles n'auraient pas
pu le faire du fait d'interfaces incompatibles.
1
17/11/2020
Patron de structure
Adaptateur
Contexte
Un service est défini par une interface; les clients appellent le
service via cette interface; les servants implantent l’interface
Problème
Réutiliser un servant qui implante une interface non-conforme
à l’interface attendue par les clients
Solution
Introduire un composant (adapter ou wrapper) représentant
une couche de transformation entre les clients et le servant
L’adapter intercepte les requêtes et réponses du servant et
les adapte de façon à les rendre conformes avec l’interface
attendue
réutilisation
Deux techniques :
L'héritage: réutilisation boîte blanche. On parle de
boîte blanche, car le contenu des classes parentes est
visible aux sous classes
La composition: réutilisation boîte noire . On parle de
boîte noire, car la nouvelle classes n'a pas accès à la
représentation interne de l'objet réutilisé.
2
17/11/2020
3
17/11/2020
Adaptateur
Target –Interface
Définit l’interface utilisée par les clients
Client
Utilise des objets conformes à l’interface Target
Adaptee
Définit une interface existante qui exige une adaptation
Adapter
Adapte l’interface d’Adaptee à l’interface Target
4
17/11/2020
5
17/11/2020
Adaptateur
6
17/11/2020
Exemple
Exemple 2
Au cours de la vie d’un logiciel, certaines classes sont
susceptibles de voir leur contrat vis-à-vis de l’extérieur
profondément modifié (changement de la signature de
méthodes, suppression de méthodes, etc.). Pour gérer ces
modifications de contrat, deux stratégies sont possibles :
Modifier l’ensemble des classes utilisatrices, ce qui peut
s’avérer rapidement rédhibitoire.
Chercher à rester parfaitement compatible avec les anciens
contrats, d’où une complexité accrue de la classe au fil des
évolutions.
Le design pattern adaptateur permet de maintenir différentes
versions d’une même classe au sein d’un logiciel. Pour cela, il
suffit de créer une classe par version.
7
17/11/2020
8
17/11/2020
Patron de structure
Façade
Intention
Fournir une interface unique, simplifiée ou unifiée, pour
accéder à un ensemble d’interfaces d’un sous-système
complexe.
Exemple
Réduire la complexité d’un système en le découpant en
plusieurs sous-systèmes ET éviter la dépendance entre les
clients et les éléments du sous-système
Principe des entrepôts de données
Patron de structure
Façade
Champs d’application
Fournir une interface unique pour un système complexe
Séparer un sous-système de ses clients
9
17/11/2020
Patron de structure
Façade
Structure
La Façade connaît quelles classes du sous-système sont
responsables de telle ou telle requête, et délègue donc les
requêtes aux objets appropriés
Les classes sous-jacentes à la façade implémentent les
fonctionnalités
Le nombre de classes n’est pas limité
Les clients manipulent le sous-système en s’adressant à la
façade (ou aux éléments du sous-système rendus publics par
la façade)
La façade transmet les requêtes au sous-système après
transformation si nécessaire
Patron de structure
Façade
Conséquences
Facilite l’utilisation par la simplification de l’interface
Diminue le couplage entre le client et le sous-système
Ne masque pas forcément les éléments du sous-système (un
client peut utiliser la façade ou le sous-système)
Permet de modifier les classes du sous-système sans affecter
le client
Peut masquer les éléments privés du sous-système
L’interface unifiée présentée par la façade peut être trop
restrictive
10
17/11/2020
11
17/11/2020
12
17/11/2020
même si tous deux ont un rôle d’encapsulation, leur méthode d’encapsulation diffère
13
17/11/2020
Patron de structure
Bridge
Intention
Découple l’abstraction (interface) de l’implémentation afin de permettre
aux deux de varier indépendamment
Partager une implémentation entre de multiples objets
Exemple
MVC: découplage entre les facettes (interfaces de communications)
Permet de développer des représentations interchangeables
Structure
Programmation par deux interfaces
Conséquence
Modularité, indépendance, réutilisation
Masquer les détails d’un côté à l’autre
Birdge
14
17/11/2020
Exemple
RedColor
Proxy
Contexte
Le client a besoin d’accéder aux services d’un autre composant (ex. objet, base
de données, page html ou image)
L’accès direct est possible du point de vue technique mais sans être la
meilleure solution
Problème
Objet distant. L’utilisation de ses services présuppose l’initialisation d’une
communication via un protocole spécifique (RMI, IIOP, SOAP, etc.).
Accès contrôlés à l’objet. La sécurité du logiciel s’impose à certains objets
critiques, et l’appel de leurs méthodes est conditionné par un niveau
d’autorisation suffisant.
Objet coûteux à instancier. Une stratégie de création des instances est
nécessaire
Solution
Le client communique avec le représentant (proxy) plutôt qu’avec le composant
Le proxy offre l’interface du composant mais exécute des procédures
additionnelles avant (pre) et après (post) l’invocation du composant
15
17/11/2020
Proxy
Proxy
Proxy
Offre aux clients l’interface de l’Original
Assure l’accès sécurisé, efficace et correct à l’Original
AbstractOriginal
Définit l’interface (ou la classe de base) pour l’Original et le Proxy
Ainsi, le Proxy peut être utilisé à tout endroit où l’Original est attendu
Original
Implémente les services décrits dans l’AbstractOriginal
Définit l’objet réel représenté par le Proxy
Client
Utilise l’interface du Proxy pour requérir les services de l’Original
16
17/11/2020
Proxy
17
17/11/2020
Exemples
Proxy distant
Est le représentant local d’un objet situé dans un autre espace
d’adressage
Ex: le Stub de RMI, CORBA, Java EE, .NET, …
Exemples
Proxy virtuel
Crée des objets coûteux à la demande (lazyloading, caching,
…)
Ex: reporter la création d’un client email jusqu’à la première
utilisation
Ex: utiliser un cache local d’images
Proxy de protection
Contrôle l’accès au composant (plusieurs droits d’accès sont
possibles)
ex: Serveur d’Application –le traitement d’une requête client
n’est pas démarré si les droits d’accès du client sont
insuffisants
18
17/11/2020
Patron de structure
Composite
Intention
Composer des objets dans des structures d’arbre pour
représenter des hiérarchies composants/composés
Composite permet au client de manipuler uniformément les
objets simples et les objets au sein de leurs compositions
Exemple
JComponent / JButton, JLabel, etc. ou java.awt.Component
/ java.awt.Container
Patron de structure
Composite
Champs d’application
Une classe abstraite qui représente à la fois les
primitives (contenues) et les containers
Représentation de hiérarchie composants / composés
19
17/11/2020
Patron de structure
Composite
20
17/11/2020
Patron de structure
Composite
Structure
Component (java.awt.Component)
déclare l’interface commune à tous les objets
implémente le comportement par défaut pour toutes les classes si
nécessaire
déclare l’interface pour gérer les composants fils
Définit l’interface pour accéder au composant parent (optionnel )
Leaf représente une feuille (java.awt.Button)
Implémentation du comportement
Composite (java.awt.Container) définit le comportement des composants
ayant des fils, stocke les fils et implémente les opérations nécessaires à
leur gestion
Lien dans la hiérarchie
Comportement : fusion des comportements des fils
Les clients (affichage graphique) utilise l’interface Component, si le
receveur est une feuille la requête est directement traitée, sinon le
Composite retransmet habituellement la requête à ses fils en effectuant
éventuellement des traitements supplémentaires avant et/ou après
Composite (exemple)
21
17/11/2020
Composite (exemple)
Composite (exemple)
22
17/11/2020
Exemple : expression
Nombre expression
Addition
Exemples
Une Expression de type composite (Expression)
• Expression e = new Addition(new Nombre(1),new
Nombre(3));
Une Expression de type composite (API AWT)
23
17/11/2020
Patron de structure
Décorateur
Intention
Attacher dynamiquement des capacités additionnelles à un
objet
Fournir ainsi une alternative flexible à l’héritage pour
étendre les fonctionnalités
Champs d’application
Pour ajouter des capacités de manière transparente
Pour des capacités qui peuvent être retirées
Quand l’extension par héritage produirait un nombre
trop important d’extensions indépendantes
Quand l’héritage est interdit
Patron de structure
Décorateur
24
17/11/2020
Décorateur
La classe abstraite Composant définit le point de départ de ce diagramme.
Plusieurs ComposantConcret peuvent hériter de Composant
décorateur: une classe abstraite héritant de Composant et ayant un attribut de
type Composant.Decorateur déclare abstraite la méthode dont l’on souhaite
étendre les fonctionnalités.
Pour ajouter des fonctionnalités à un ensemble de ComposantConcret on va
créer des classes DecorateurConcret qui héritent de Decorateur.
Un DecorateurConcret contient un constructeur permettant d’initialiser l’attribut
composant présent dans le décorateur.
la classe DecorateurConcret redéfinisse la méthode déclarée abstraite dans le
décorateur. Lors de cette redéfinition il est possible d’étendre les fonctionnalités
en appelant la méthode de l’attribut composant et en ajoutant des traitements.
Ce pattern utilise largement l’héritage mais il utilise aussi la composition grâce à
l’attribut Composant présent dans le décorateur. C’est l’alliance de ces deux
procédés qui permet à ce pattern d’être si efficace.
Exemple 1
Un autre exemple : un texte décoré par des balises
HTML
<b><i>exemple</i><b>
25
17/11/2020
B,I,…
public class B extends TexteDécoré{
public B(TexteI unTexte){
super(unTexte);
}
public String toHTML(){
return "<B>" + super.toHTML() + "</B>";
}
}
public class I extends TexteDécoré{
public I(TexteI unTexte){
super(unTexte);
}
public String toHTML(){
return "<I>" + super.toHTML() + "</I>";
}
}
26
17/11/2020
décoration
TexteI t = new B( new I( new Texte("Exemple")));
String s = t.toHTML();
Exemple 2
27
17/11/2020
Exemple3
Exercice
A un distributeur, les clients ont le choix entre 3 types de café :
Colombia (1 D),Expresso (1.2 D) et Deca (0.8D). Ils peuvent ajouter
les suppléments suivants : Lait, Sucre, Caramel, Chantilly. L'ajout de
sucre ou de lait est facturé 0.2 D, de caramel 0.4D et de chantilly
0.8D. Il faut garder à l'esprit que l'ajout futur de nouveaux ingrédients
(café ou supplément) doit être simplifié. On veut afficher dans la
console le prix du café choisi avec ses suppléments.
1) Donner le diagramme de classe modélisant ce distributeur
28
17/11/2020
29
17/11/2020
Poids-mouche (flyweight)
Intention
Exemple
pour représenter des caractères ou des icônes à l'écran, ce type de patron de
conception est apprécié. Ainsi, chaque caractère peut être représenté par une
instance d'une classe contenant sa police, sa taille, etc. La position des
caractères à afficher est stockée en dehors de cette classe. Ainsi, on a une
seule instance de la classe par (type de) caractère et non une instance par
caractère affiché à l'écran.
30
17/11/2020
Structure
Structure
RESPONSABILITES :
PoidsMouche : déclare l'interface permettant à l'objet de recevoir et d'agir en
fonction de données extrinsèques. On externalise les données extrinsèques d'un
objet PoidsMouche afin qu'il puisse être réutilisé.
ConcretePoidsMouche : implémente l'interface poids-mouche. Les informations
contenues dans un ConcretePoidsMouche sont intrinsèques (sans lien avec son
contexte). Puisque, ce type de poids-mouche est obligatoirement partagé.
ConcretePoidsMoucheNonPartage : implémente l'interface poids-mouche. Ce type
de poids-mouche n'est pas partagé. Il possède des données intrinsèques et
extrinsèques.
PoidsMoucheFabrique : fournit une méthode retournant une instance
de PoidsMouche. Si les paramètres de l'instance souhaitée correspondent à
un PoidsMouche partagé, l'objet PoidsMoucheFabrique retourne une instance déjà
existante. Sinon l'objetPoidsMoucheFabrique crée une nouvelle instance.
La partie cliente demande à PoidsMoucheFabrique de lui fournir un PoidsMouche.
31
17/11/2020
Exemple
Dans un logiciel de DAO
Le trait a une épaisseur (simple ou double), une continuité (continu, en pointillé), une
ombre ou pas, des coordonnées. Les caractéristiques d'épaisseur, de continuité et
d'ombre sont des attributs intrinsèques à un trait, tandis que les coordonnées sont des
attributs extrinsèques. Plusieurs traits possèdent des épaisseurs, continuité et ombre
similaires. Ces similitudes correspondent à des styles de trait.
En externalisant les attributs intrinsèques des objets (style de trait), on peut avoir en
mémoire une seule instance correspondant à un groupe de valeurs (simple-continu-
sans ombre, double-pointillé-ombre).
Chaque objet avec des attributs extrinsèques (trait avec les coordonnées) possède
une référence vers une instance d'attributs intrinsèques (style de trait). On obtient
deux types de poids-mouche : les poids-mouche partagés (style de trait) et les poids-
mouche non partagés (le trait avec ses coordonnées).
La partie cliente demande le poids-mouche qui l'intéresse à la fabrique de poids-
mouche. S'il s'agit d'un poids-mouche non partagé, la fabrique le créera et le
retournera. S'il s'agit d'un poids-mouche partagé, la fabrique vérifiera si une instance
existe. Si une instance existe, la fabrique la retourne, sinon la fabrique la crée et la
retourne.
32
15/12/2020
1
15/12/2020
Exemple introductif
Dans de nombreuses situations il faut choisir un algorithme au sein
d'une famille afin de traiter au mieux la situation courante.
Prenons, par exemple, un problème classique de tri de liste.
Patron de comportement
Pattern Strategy
4
2
15/12/2020
Pattern Strategy
Pattern Strategy
3
15/12/2020
Patron de comportement
Pattern Strategy
7
Structure
Contexte: maintient une référence à l’objet Strategy. Il peut définir une
interface qui permet à l’objet Strategy d’accéder à ses données
Stratégie: déclare une interface commune à tous les algorithmes
ConcreteStrategy implémente l’algorithme en utilisant l’interface
Strategie
Déroulement
Le Contexte envoie les requêtes de ses clients à l’une de ses stratégies.
Les clients créent la classe concrète qui implémente l’algorithme.
Puis ils passent la classe au Contexte.
Enfin ils interagissent avec le Contexte exclusivement.
Patron de comportement
Pattern Strategy
8
Champs d’application
Lorsque de nombreuses classes associées ne diffèrent
que par leur comportement
Lorsqu’on a besoin de plusieurs variantes d’un
algorithme
Lorsqu’un algorithme utilise des données que les clients
ne doivent pas connaître
Lorsqu’une classe définit plusieurs comportements
4
15/12/2020
5
15/12/2020
6
15/12/2020
Template method
7
15/12/2020
Template method
AbstractClasse : définit des méthodes abstraites
primitives. La classe implémente le squelette d'un
algorithme qui appelle les méthodes primitives.
ConcreteClasse : est une sous-classe concrète de
AbstractClasse. Elle implémente les méthodes utilisées
par l’algorithme de la méthode
TemplateMethod() de AbstractClasse.
La partie cliente appelle la méthode
de AbstractClasse qui définit l'algorithme.
Exemple
cas d'un document informatique: le document a
un fonctionnement global où il est sauvegardé.
Pour la sauvegarde, il y aura toujours besoin
d'ouvrir le fichier, d'écrire dedans, puis de fermer
le fichier. Mais, selon le type de document, il ne
sera pas sauvegardé de la même manière. S'il
s'agit d'un document de traitement de texte, il
sera sauvegardé en suite d'octets. S'il s'agit d'un
document HTML, il sera sauvegardé dans un
fichier texte.
8
15/12/2020
Template method
Template method
Exemple
9
15/12/2020
Template Method
Différence entre patrons Strategie et Template Method :
Le patron Strategie encapsule une famille d'algorithmes dans
des objets, permettant à l'utilisateur d'utiliser et d'ajouter des
algorithmes facilement.
Le patron Template method définit le squelette d'un algorithme
dont certaines parties sont implémentées différemment par les
sous-classes. La methode templateMethode contrôle la structure
de l'algorithme. Ceci permet de :
Supprimer la duplication du code et maximiser sa réutilisation
La mise a jour d'un bout de code se fait a une seule place.
Contrôle des extensions permises aux sous-classes.
Chaîne de Responsabilités
10
15/12/2020
Chaîne de Responsabilités
Contexte
Le système doit traiter une requête
La requête peut être traitée de plusieurs façons (par plusieurs
objets)
Problème
Différents objets peuvent traiter une requête et on ne sait pas a
priori lequel
L'ensemble des objets pouvant traiter une requête doit être
facilement modifiable
Solution
Isoler les différents parties d’un traitement dans différents
objets
Faire passer la requête via une chaîne d’objets (maillons)
Chaque maillon peut traiter la requête et/ou la faire passer au
maillon suivant
Chaîne de responsabilités
11
15/12/2020
Chaîne de Responsabilités
Exemples
Transformer un fichier XML a besoin de plusieurs filtres : traiter
du code , des images, des liens…
Les besoins sont les suivants :
Plusieurs filtres permettant de remplacer le contenu original par un
nouveau contenu
Pouvoir enchaîner les filtres dynamiquement
Pouvoir ajouter un filtre en cas d'oubli ou de nouveau besoin
le pattern chaine de responsabilités peut être la solution
12
15/12/2020
Exemples
Interface IMoyenDeRecherche {
public function trouve ($personne);
}
class PagesJaunes implements IMoyenDeRecherche
{/**/}
class Internet implements IMoyenDeRecherche
{/**/}
Patron de comportement
Etat (State)
26
13
15/12/2020
Etat (State)
Etat (Stat)
niveauCournat : Etat
14
15/12/2020
Etat (State)
Exemple(1/2)
15
15/12/2020
Exemple(2/2)
Etat (state)
Le pattern State permet de :
simplifier l'ajout et la suppression d'un Etat
supprimer des traitements conditionnels de grande
taille
Rendre les transitions entre états explicites
16
15/12/2020
Exemple : Etat
Observer
Problème : Comment faire savoir a un ensemble d'objets
(observateur/abonne/observer) qu'un autre objet
(observé/sujet/publieur/observable) dont ils dépendent a été
modifié?
17
15/12/2020
Observer
observer
18
15/12/2020
Observer
Exemple: observer
19
15/12/2020
Patron de comportement
Command
39
Intention
Encapsuler une requête comme un objet
Permettre de défaire des traitements (undo)
But
Découpler la réception d'une requête de son exécution
Contexte
Réaliser un traitement sans avoir besoin de savoir de quoi il
s'agit et de qui va l'exécuter
Découpler les objets qui invoquent une action de ceux qui
l'exécutent
Command
Structure
20
15/12/2020
Patron de comportement
Command
41
L’objet ConcreteCommand
invoque les opérations du
destinataire pour exécuter la
requête.
Command
Command
déclare une interface pour exécuter une opération.
ConcreteCommand (PasteCommand, OpenCommand)
Définit une liaison entre l’objet destinataire et l’action
Implémente “execute” par l’invocation d’ opérations sur le destinataire.
Client (Application)
Crée un objet ConcreteCommand et assigne son destinataire.
Invoker (MenuItem)
Demande à la commande de s’exécuter.
Destinataire (Document, Application)
Sait comment exécuter les opérations associées à la requête.
N’importe quelle classe peut agir comme destinataire.
21
15/12/2020
command
Exemple: command
22
15/12/2020
Exemple: command
public interface Order {
public abstract void execute ( ); //ConcreteCommand Class.
} class BuyStockOrder implements Order {
// Receiver class. private StockTrade stock;
public BuyStockOrder ( StockTrade st) {
class StockTrade { stock = st;
public void buy() { }
System.out.println("You want to buy public void execute( ) {
stocks"); stock . buy( );
}
} }
public void sell() {
System.out.println("You want to sell stocks //ConcreteCommand Class.
"); class SellStockOrder implements Order {
private StockTrade stock;
} public SellStockOrder ( StockTrade st) {
} stock = st;
// Invoker. }
class Agent { public void execute( ) {
stock . sell( );
private m_ordersQueue = new ArrayList(); }
public Agent() { } }
void placeOrder(Order order) {
ordersQueue.addLast(order);
order.execute(ordersQueue.getFirstAndRemov
e());
}
Exemple : command
// Client
public class Client {
public static void main(String[]
args) {
StockTrade stock = new
StockTrade();
BuyStockOrder bsc = new
BuyStockOrder (stock);
SellStockOrder ssc = new
SellStockOrder (stock);
Agent agent = new Agent();
agent.placeOrder(bsc);
agent.placeOrder(ssc);
}
}
23
15/12/2020
Mémento
Sauvegarder l'état interne d'un objet en respectant
l'encapsulation, afin de le restaurer plus tard.
Intention
Permettre à l'utilisateur
de revenir en arrière
pour se reconstituer après des erreurs.
Mémento
24
15/12/2020
Mémento
Mémento
25
15/12/2020
Mémento
EXEMPLE
un éditeur de document disposant d'une fonction
d'annulation. La fonction d'annulation est sur plusieurs
niveaux.
Les informations de l'état interne (état du document) sont
conservées dans un mémento. L'objet avec l'état interne
(document) est le créateur du mémento. Afin de respecter
l'encapsulation, les valeurs du mémento ne sont visibles que
par son créateur. Ainsi, l'encapsulation de l'état interne est
préservée. Un autre objet est chargé de conserver les
memento (gestionnaire d'annulation) : il s'agit du gardien.
itérateur
26
15/12/2020
Itérateur
Itérateur
Compose : définit l'interface d'un objet composé permettant de
créer un Iterateur.
ConcreteCompose : est une sous-classe de l'interface Compose. Elle
est composée d'éléments et implémente la méthode de création
d'un Iterateur.
Iterateur : définit l'interface de l'itérateur, qui permet d'accéder aux
éléments de l'objet Compose.
ConcreteIterateur : est une sous-classe de l'inteface Iterateur. Elle
fournit une implémentation permettant de parcourir les éléments
de ConcreteCompose. Elle conserve la trace de la position courante.
La partie cliente demande à l'objet Compose de fournir un
objet Iterateur. Puis, elle utilise l'objet Iterateur afin de parcourir les
éléments de l'objet Compose.
27
15/12/2020
Exemple
Itérateur
28
15/12/2020
Patron de comportement
Visitor
57
Intention
Représenter UNE opération à effectuer sur les éléments
d’une structure
Permet de définir une nouvelle opération sans changer les
classes des éléments sur lesquels on opère
Exemple
Un arbre de syntaxe abstraite pour un compilateur, un outil
XML…Différents traitement sur le même arbre : type check,
optimisation, analyses…
Patron de comportement
Visitor
58
Champs d’application
Une structure contient beaucoup de classes aux
interfaces différentes
Les classes définissant la structure changent peu, mais
de nouvelles opérations sont toujours nécessaires
éviter la pollution des classes de la structure
29
15/12/2020
Patron de comportement
Visitor
60
Structure
ObjectStructure (le programme demandeur) peut
énumérer ses éléments de type Element et peut être un
Composite
Element définit une opération accept qui prend un
Visitor en paramètre
ConcreteElement implémente l’opération accept
30
15/12/2020
Patron de comportement
Visitor
61
Structure
Visitor
déclare l’opération de visite pour chaque classe de ConcreteElement
dans la structure
La signature (et le nom) de l’opération identifie la classe qui envoie la
requête de visite au visiteur. Le visiteur détermine alors la classe
concrète et accède à l’élément directement
ConcreteVisitor
Implémente chaque opération déclarée par Visitor
Chaque opération implémente un fragment de l’algorithme, et un état
local peut être stocké pour accumuler les résultats de la traversée de
la structure
Patron de comportement
Visitor
62
Déroulement
Un objectStructure parcours ses éléments (différentiation selon le type possible) et
envoie le visiteur (elt.accept(visiteur))
Les éléments appelent (à tour de rôle) l’opération du visiteur (visiteur.visit(this))
Le visiteur agrège les données aux travers d’appel de méthode des éléments
(paramètres de visit)
31
15/12/2020
Patron de comportement
Visitor
63
Conséquences
Ajout de nouvelles opérations très facile
Groupement/séparation des opérations communes
Ajout de nouveaux ConcreteElement complexe (opération
dépendant du type…)
Visitor traverse des structures où les éléments sont de types
complètement différents / Iterator
Accumulation d’état dans le visiteur plutôt que dans des
arguments
Suppose que l’interface de ConcreteElement est assez riche
pour que le visiteur fasse son travail => cela force à
montrer l’état interne et à casser l’encapsulation
32
15/12/2020
33
15/12/2020
Avec Visiteurs
34
15/12/2020
35
15/12/2020
36
15/12/2020
Draw
Draw
37
15/12/2020
Médiateur
Au fur et à mesure que l’on ajoute des classes complexes à
une application, la communication entre plusieurs classes
complexes devient difficile à gérer
Le couplage entre les classes devient plus important
Ce patron cherche à pallier ce problème avec la conception
d’une classe «médiatrice» qui, elle seule, connaît la
complexité de chaque classe.
Les classes complexes se communiquent entre elles à travers
la classe médiatrice.
Gérer la transmission d'informations entre des objets interagissant entre
eux.
Avoir un couplage faible entre les objets puisqu'ils n'ont pas de lien
direct entre eux.
Pouvoir varier leur interaction indépendamment.
médiateur
Différents objets ont des interactions. Un événement sur
l'un provoque une action ou des actions sur un autre ou
d'autres objets.
Cela peut être les éléments d'IHM. Si une case est
cochée, certains éléments deviennent accessibles. Si une
autre case est cochée, des couleurs de l'IHM changent.
Si les classes communiquent directement, il y a un
couplage très fort entre elles. Une classe dédiée à la
communication permet d'éviter cela. Chaque élément
interagissant (élément de l'IHM) sont des collègues. La
classe dédiée à la communication est un médiateur.
38
15/12/2020
Médiateur : Intension
Médiateur
39
15/12/2020
Médiateur
Collegue : définit l'interface d'un collègue. Il s'agit
d'une famille d'objets qui s'ignorent entre eux mais qui
doivent se transmettre des informations.
ConcreteCollegueA et ConcreteCollegueB : sont des
sous-classes concrètes de l'interface Collegue. Elles ont
une référence sur un objet Mediateur auquel elles
transmettront les informations.
Mediateur : définit l'interface de communication entre
les objets Collegue.
ConcreteMediateur : implémente la communication et
maintient une référence sur les objets Collegue.
40
15/12/2020
Avant le médiateur
41
15/12/2020
Après le médiateur
42
15/12/2020
Façade vs Médiateur
La Façade et le Médiateur ont des rôles similaires :
ils essayent de faire collaborer des classes
étroitement liées.
La façade définit une interface simplifiée pour un sous-
système d’objets, mais elle n’ajoute pas de nouvelles
fonctionnalités. Le sous-système est conscient de
l’existence de la façade. Les objets situés à l’intérieur
du sous-système peuvent communiquer directement.
Le médiateur centralise la communication entre les
composants du système. Les composants ne voient que
l’objet médiateur et ne communiquent pas directement.
43
15/12/2020
Médiateur vs Observateur
La différence entre le Médiateur et l’Observateur est souvent
très fine.
Le but principal du médiateur est d’éliminer les dépendances
mutuelles entre un ensemble de composants du système. À la
place, ces composants peuvent devenir dépendants d’un
unique objet médiateur. Le but de l’observateur est d’établir
des connexions dynamiques à sens unique entre les objets, où
certains objets peuvent être les subordonnés d’autres objets.
Il existe une implémentation populaire du médiateur qui
repose sur l’observateur. L’objet médiateur joue le rôle du
diffuseur et les composants agissent comme des souscripteurs
qui s’inscrivent et se désinscrivent des événements du
médiateur. Lorsque ce type de conception est mis en place,
le médiateur ressemble de près à l’observateur.
44