Annexes Design Patterns

1. Catalogue visuel des 23 patterns GoF

Patterns Création (5)

Singleton
┌────────────────────┐
│    Singleton       │
├────────────────────┤
│ - instance         │
├────────────────────┤
│ + getInstance()    │
└────────────────────┘

Factory Method
┌──────────────┐       ┌──────────────┐
│ <<abstract>> │       │   Product    │
│   Creator    │       └──────────────┘
│              │                ▲
│ + factory()  │       ┌───────┴───────┐
│ + operation()│       │               │
└──────┬───────┘   ConcreteP1    ConcreteP2
       │
  ┌────┴────┐
ConcreteCreator

Abstract Factory
┌────────────────┐       ┌────────────────┐
│ <<interface>>  │       │ <<interface>>  │
│ AbstractFactory│       │ AbstractProduct│
├────────────────┤       ├────────────────┤
│ + createA()    │       │ + operation()  │
│ + createB()    │       └────────────────┘
└───────┬────────┘
        │
   ┌────┴────┐        ┌──────────┐
ConcreteFactory   ConcreteProductA

Builder
┌───────────┐       ┌──────────┐
│  Builder  │       │ Director │
├───────────┤       ├──────────┤
│ + buildA()│       │ + build()│
│ + buildB()│       └──────────┘
│ + getResult()│
└───────────┘
       ▲
       │
ConcreteBuilder

Prototype
┌──────────────────┐
│ <<interface>>    │
│   Prototype      │
├──────────────────┤
│ + clone()        │
└──────────────────┘
        ▲
        │
  ConcretePrototype

Patterns Structure (7)

Adapter
┌──────────┐      ┌──────────┐      ┌──────────┐
│  Client  │──────│  Target  │      │  Adaptee │
│          │      │ (interf) │      │          │
└──────────┘      └──────────┘      │ + specOp │
                        ▲           └──────────┘
                        │                 ▲
                   ┌────┴─────┐           │
                   │  Adapter │───────────┘
                   │ + request│
                   └──────────┘

Bridge
┌──────────────────┐      ┌──────────────────┐
│   Abstraction    │──────│  <<interface>>   │
├──────────────────┤      │   Implementor    │
│ + operation()    │      ├──────────────────┤
└──────────────────┘      │ + implOp()       │
        ▲                 └──────────────────┘
        │                         ▲
RefinedAbstraction          ┌────┴────┐
                           ConcImplA  ConcImplB

Composite
┌──────────────────┐
│ <<interface>>    │
│   Component      │
├──────────────────┤
│ + operation()    │
│ + add(c)         │
│ + remove(c)      │
└──────────────────┘
        ▲
   ┌────┴────┐
   │         │
   Leaf    Composite

Decorator
┌──────────────────┐
│ <<interface>>    │
│   Component      │
├──────────────────┤
│ + operation()    │
└──────────────────┘
        ▲
   ┌────┴────┐
ConcreteComp  Decorator
              └── component
              ├── operation()

Facade
┌──────────────────────┐
│       Facade         │
├──────────────────────┤
│ + simplifiedOp()     │
└──────────┬───────────┘
           │
    ┌──────┼──────┐
    │      │      │
 SubA   SubB   SubC

Flyweight
┌──────────────┐
│  Flyweight   │
├──────────────┤
│ + operation()│
└──────────────┘
       ▲
       │
ConcreteFlyweight
   (intrinsic state)

Proxy
┌──────────────────┐      ┌──────────────────┐
│ <<interface>>    │      │  RealSubject     │
│    Subject       │      ├──────────────────┤
├──────────────────┤      │ + request()      │
│ + request()      │      └──────────────────┘
└──────────────────┘              ▲
        ▲                        │
        │                    ┌────┴────┐
        └────────────────────│  Proxy  │
                             │ + request│
                             └──────────┘

Patterns Comportement (11)

Chain of Responsibility
┌──────────┐      ┌──────────┐      ┌──────────┐
│ Handler  │──────│ Handler  │──────│ Handler  │
│ + handle()│     │ + handle │      │ + handle │
└──────────┘      └──────────┘      └──────────┘

Command
┌──────────┐      ┌──────────┐      ┌──────────┐
│ Invoker  │──────│ Command  │──────│ Receiver │
│          │      │ + exec() │      │ + action │
└──────────┘      └──────────┘      └──────────┘
                        ▲
                   ┌────┴────┐
               ConcreteCommand

Interpreter
┌──────────────┐
│  Expression  │
├──────────────┤
│ + interpret()│
└──────────────┘
        ▲
   ┌────┴────┐
 Terminal  NonTerminal

Iterator
┌──────────┐      ┌──────────┐
│ Aggregate│──────│ Iterator │
│ + iter() │      │ + next() │
└──────────┘      │ + hasNext│
                  └──────────┘

Mediator
┌──────────┐      ┌──────────┐
│  Colleague│──────│ Mediator │
└──────────┘      └──────────┘
        ▲
        │
  ConcreteColleague

Memento
┌──────────┐      ┌──────────┐      ┌──────────┐
│ Originator│──────│ Memento  │      │ Caretaker│
│ + save()  │      │ + state()│      │          │
│ + restore │      └──────────┘      └──────────┘
└──────────┘

Observer
┌──────────┐      ┌──────────┐
│  Subject │──────│ Observer │
│ + attach │      │ + update │
│ + notify │      └──────────┘
└──────────┘

State
┌──────────┐      ┌──────────┐
│ Context  │──────│  State   │
│ + request│      │ + handle │
└──────────┘      └──────────┘
                        ▲
                   ┌────┴────┐
               ConcreteStateA  B

Strategy
┌──────────┐      ┌──────────┐
│ Context  │──────│ Strategy │
│ + execute│      │ + algo() │
└──────────┘      └──────────┘
                        ▲
                   ┌────┴────┐
               ConcreteStratA  B

Template Method
┌────────────────┐
│ AbstractClass  │
├────────────────┤
│ + template()   │ (final)
│ + step1()      │ (abstract)
│ + step2()      │ (virtual/hook)
└────────────────┘
        ▲
        │
  ConcreteClass

Visitor
┌──────────┐      ┌──────────┐
│ Element  │──────│ Visitor  │
│ + accept │      │ + visitA │
└──────────┘      │ + visitB │
        ▲         └──────────┘
   ┌────┴────┐
 ConcreteElemA/B

2. Cheat sheets UML

Relations entre classes

Inheritance:  ────▷           Inheritance/implements
Association:  ─────>          Reference ("has-a")
Aggregation:  ────◇           Weak "has-a" (optional parts)
Composition:  ────◆           Strong "has-a" (parts created/destroyed with)
Dependency:   - - - >         Temporary/short reference

Stéréotypes

<<interface>>    Interface
<<abstract>>     Abstract class
<<enum>>         Enumeration
<<value>>        Value Object
<<entity>>       Entity (DDD)
<<service>>      Service

Multiplicité

1          Exactly one
0..1       Zero or one
*          Zero or more
1..*       One or more
0..n       Zero to n

3. Mapping Pattern-Langage

Pattern	TypeScript	Java	PHP	Python
Singleton	class + private constructor	enum + private constructor	trait + static	new override
Factory Method	abstract class	abstract class	abstract class	ABC + factory
Abstract Factory	interface + implementations	interface	interface	Protocol
Builder	class with fluent API	class with builder pattern	class with chain	class with methods
Adapter	class wrapping	implements interface	implements	class wrapping
Decorator	class wrapping	class wrapping	trait	decorator pattern
Composite	interface + recursive	interface	interface	abstract class
Facade	class hiding subsystem	class	class	class
Proxy	class implementing interface	class	class	class
Observer	EventEmitter	PropertyChangeListener	SplObserver	asyncio
Strategy	interface + lambda	interface	interface	function + callable
Command	class + execute()	class	class	class + call

4. Glossaire

Abstraction : Séparation des concepts de leurs implémentations concrètes.

Agrégation : Relation "has-a" faible où l'objet contenu peut exister sans le conteneur.

Anti-pattern : Solution couramment utilisée mais inefficace ou contre-productive.

Classe abstraite : Classe ne pouvant être instanciée, servant de base à d'autres classes.

Cohésion : Mesure de la pertinence des responsabilités d'une classe (haute cohésion = bonne).

Composition : Relation "has-a" forte où les parties sont créées/détruites avec le tout.

Couplage : Degré de dépendance entre classes (faible couplage = bonne).

Délégation : Déléguer une responsabilité à un autre objet plutôt que l'implémenter directement.

DIP (Dependency Inversion Principle) : Dépendre des abstractions, pas des concrétions.

DRY (Don't Repeat Yourself) : Principe d'éviter la duplication de code.

Encapsulation : Masquer les détails d'implémentation derrière une interface publique.

GoF (Gang of Four) : Les quatre auteurs du livre fondateur "Design Patterns" (Gamma, Helm, Johnson, Vlissides).

Hook : Méthode optionnelle dans un Template Method qui peut être surchargée.

Immutabilité : Propriété d'un objet dont l'état ne peut pas être modifié après création.

Interface : Contrat définissant les méthodes que les classes implémentant doivent fournir.

Lazy initialization : Technique de création différée d'un objet jusqu'à son premier usage.

Mixin : Classe fournissant des méthodes réutilisables, utilisée via héritage multiple ou traits.

Mock : Objet simulé utilisé dans les tests pour imiter le comportement d'un objet réel.

OCP (Open/Closed Principle) : Ouvert à l'extension, fermé à la modification.

Polymorphisme : Capacité d'objets de types différents à répondre au même message.

Refactoring : Restructuration du code sans changer son comportement externe.

Responsabilité : Raison pour laquelle une classe peut être modifiée (SRP : une seule responsabilité).

SOLID : Acronyme des 5 principes de conception orientée objet.

SRP (Single Responsibility Principle) : Une classe ne doit avoir qu'une seule raison de changer.

Thread-safe : Code conçu pour fonctionner correctement en environnement multithreadé.

UML (Unified Modeling Language) : Langage de modélisation graphique pour le génie logiciel.

YAGNI (You Ain't Gonna Need It) : Principe de ne pas ajouter de fonctionnalités non nécessaires.

24. Annexes - Design Patterns