Informatique · Conception

Design patterns

Certains problèmes reviennent dans presque tous les programmes : créer le bon objet, prévenir les abonnés, échanger un algorithme.

Déjà à l'aise ? Aller au quiz

Le principe

Une solution éprouvée à un problème qui revient, avec un nom. On l'adapte à chaque projet.

créationnels Factory créer structurels Adapter assembler comportementaux Observer collaborer

Trois familles, selon ce que le pattern aide à faire.

23 patterns

Catalogués en 1994 par le « Gang of Four », répartis en trois familles.1

Un problème revient ? Il a déjà un nom.

Après cette fiche, tu sais

  • dire ce qu'est un patron de conception et nommer ses trois familles ;
  • reconnaître et écrire en Java Singleton, Factory, Observer, Builder et Strategy ;
  • choisir le pattern qui répond à une situation concrète ;
  • retrouver l'intention des 23 patterns du « Gang of Four ».
Question à garder en tête : pour accepter un nouveau moyen de paiement, faut-il forcément modifier la classe Panier ?

Oui, non ? Je ne sais pas encore.

Garde ta réponse en tête : on la vérifie dans la séquence « Du if à Strategy ».

Une solution qui a un nom

Introduction

Des solutions qui ont un nom

Un design pattern (patron de conception) est une solution éprouvée à un problème de conception qui revient souvent, décrite de façon assez générale pour s'adapter à chaque projet.

problème qui revient solution éprouvée, nommée ton code adapté

Le Gang of Four

En 1994, Erich Gamma, Richard Helm, Ralph Johnson et John Vlissides, surnommés le « Gang of Four » (GoF), en ont catalogué 23 dans le livre Design Patterns: Elements of Reusable Object-Oriented Software.1

Trois familles : créationnels (comment créer les objets), structurels (comment les assembler) et comportementaux (comment ils collaborent).

Les cinq à connaître

Voici les cinq qu'on croise le plus souvent. La carte de la fin présente les 23.

  • Singleton, créationnel : une seule instance
  • Factory, créationnel : créer sans écrire new
  • Observer, comportemental : prévenir les abonnés
  • Builder, créationnel : construire étape par étape
  • Strategy, comportemental : des algorithmes interchangeables

Une seule instance, partout

Pattern 1 · Créationnel

Singleton : une seule instance

Une seule instance de la classe dans toute l'application (définition), avec un point d'accès global.

ClientA ClientB ClientC Instance unique getInstance() trois clients, un seul objet

Utilisation : un journal (logger), la configuration de l'application.

Version paresseuse

public class Database {
    private static Database instance;
    private Database() {} // Constructeur privé
    public static Database getInstance() {
        if (instance == null) {
            instance = new Database();
        }
        return instance;
    }
}

Attention en multithread

Cette version paresseuse n'est pas sûre : deux fils peuvent passer le test instance == null en même temps et créer deux instances.

deux fils, en même temps Fil 1 instance == null new Database() Fil 2 instance == null new Database() deux instances au lieu d'une

La parade

En Java, on préfère l'idiome du holder (une classe interne statique qui porte l'instance, créée au premier accès par la JVM) ou un enum à une seule valeur, recommandé par Joshua Bloch dans Effective Java.2

classe Database classe interne Holder (statique) instance créée au premier accès, par la JVM

Singleton par enum

public enum Journal {
    INSTANCE;
    public void log(String message) { System.out.println(message); }
}
// Journal.INSTANCE.log("démarrage");

Comme tout état global, le Singleton complique les tests : à utiliser avec modération.

Créer sans écrire new

Pattern 2 · Créationnel

Factory : créer sans écrire new

Créer des objets sans spécifier leur classe exacte : le client demande un « chien », la fabrique choisit la classe.

client "dog" fabrique choisit la classe Dog objet le client n'écrit jamais new

Les animaux

Une interface commune, puis une classe par animal.

interface Animal { String speak(); }
class Dog implements Animal  { public String speak() { return "Ouaf !"; } }
class Cat implements Animal  { public String speak() { return "Miaou !"; } }
class Duck implements Animal { public String speak() { return "Coin !"; } }

La fabrique

class AnimalFactory {
    public Animal createAnimal(String type) {
        return switch (type) {
            case "dog"  -> new Dog();
            case "cat"  -> new Cat();
            case "duck" -> new Duck();
            default -> throw new IllegalArgumentException("type inconnu : " + type);
        };
    }
}

Un type inconnu lève une exception plutôt que de renvoyer null, qui ferait planter le client plus loin.

Trois types, trois classes

createAnimal(type) : un texte, une classe "dog" "cat" "duck" Dog Cat Duck le client ne voit que createAnimal()

Trois appels, trois objets

Fais défiler : trois appels à la fabrique, trois objets différents sur le tapis.

Scène 1 · La Factory en action

createAnimal("dog")

AnimalFactory Ouaf ! le client appelle createAnimal(type), jamais new Objets produits : 0

la fabrique exécute new Dog()

Le client

Tu as vu ? Le client n'a jamais écrit new Dog() : il demande un « dog », la fabrique choisit la classe. Pour le canard, seule la fabrique a changé.

Deux cousins du GoF

Cette « Factory » simple est un idiome courant. Le GoF décrit deux patterns plus généraux : Factory Method (une sous-classe décide quelle classe instancier) et Abstract Factory (créer des familles d'objets assortis).

Factory une méthode décide tout Factory Method une sous-classe décide la classe Abstract Factory des familles d'objets assortis dans les trois cas, le client ne choisit pas la classe

Un changement, plusieurs à prévenir

Pattern 3 · Comportemental

Observer : prévenir les abonnés

Quand un objet (le sujet) change d'état, il prévient automatiquement tous ceux qui se sont abonnés. C'est la base de la programmation par événements : interfaces graphiques, publication et abonnement, mises à jour en temps réel.

update() Subject état 1 Observateur A Observateur B Observateur C un changement, tous les abonnés prévenus

Sujet et observateurs

interface Observer {
    void update(String message);
}
class Subject {
    private List<Observer> observers = new ArrayList<>();
    public void attach(Observer o) {
        observers.add(o);
    }

Le sujet tient la liste de ses abonnés : attach() en ajoute un.

Se détacher, prévenir

    public void detach(Observer o) {
        observers.remove(o);
    }
    public void notifyObservers(String msg) {
        for (Observer o : observers) {
            o.update(msg);
        }
    }
}

notifyObservers() prévient tout le monde, detach() retire un abonné.

Un compteur qui reboucle

chaque notification change l'état état 1 état 2 état 3 puis de nouveau l'état 1

Le sujet en direct

Fais défiler : le sujet change trois fois d'état ; entre-temps, l'observateur C se détache, puis revient. Touche un observateur pour l'abonner ou le détacher toi-même.

Scène 2 · L'Observer en direct

Trois abonnés

état 1 Subject émetteur

abonnés A, B, C

C a raté une notification pendant qu'il était détaché : l'Observer ne rattrape pas le passé.

Donc il ne reçoit rien tant qu'il n'est pas réabonné ?

Exactement. Il prévient seulement les abonnés du moment.

Construire pas à pas

Pattern 4 · Créationnel

Builder : construire étape par étape

Construire des objets complexes étape par étape, au lieu d'un constructeur à rallonge dont on confond les paramètres.

chaque appel renvoie le Builder Builder setName() setAge() build() User

User et son Builder

public class User {
    private final String name, email;
    private final int age;
    private User(Builder b) { name = b.name; email = b.email; age = b.age; }

    public static class Builder {
        private String name, email;
        private int age;

Chaque étape renvoie le Builder

        public Builder setName(String n)  { name = n;  return this; }
        public Builder setEmail(String e) { email = e; return this; }
        public Builder setAge(int a)      { age = a;   return this; }
        public User build() { return new User(this); }
    }
}

Un objet, plusieurs appels

User user = new User.Builder()
    .setName("Alice")
    .setEmail("alice@example.com")
    .setAge(25)
    .build();

Chaque méthode renvoie le Builder lui-même (return this), ce qui permet d'enchaîner les appels. L'objet final peut être immuable (champs final). Le JDK en contient, par exemple HttpRequest.newBuilder().4

Ce que fabrique build()

User name = "Alice" email = "alice@example.com" age = 25 build() crée l'objet à partir des valeurs saisies

Échanger un algorithme

Pattern 5 · Comportemental

Strategy : des algorithmes interchangeables

Chaque algorithme vit dans sa propre classe, derrière une interface commune, et on choisit lequel utiliser à l'exécution.

un algorithme par classe, une seule interface Panier payer() « interface » StratégiePaiement Carte TWINT PayPal

Payer par carte ou par TWINT

interface PaymentStrategy {
    void pay(int centimes);          // montant en centimes : pas d'arrondi
}
class CreditCard implements PaymentStrategy {
    public void pay(int centimes) { /* paiement par carte */ }
}

Le panier délègue

class Twint implements PaymentStrategy {
    public void pay(int centimes) { /* paiement TWINT */ }
}
class Checkout {
    private PaymentStrategy strategy;
    public void setStrategy(PaymentStrategy s) { strategy = s; }
    public void payer(int centimes) { strategy.pay(centimes); }
}

Le panier (Checkout) ne connaît que l'interface ; on change de moyen de paiement à l'exécution avec setStrategy(new Twint()).

Ajouter Facture

on ajoute une classe, le Panier reste le même Panier payer() « interface » StratégiePaiement Carte TWINT PayPal Facture Panier : aucune ligne modifiée

Du if à Strategy

Fais défiler : voici comment on y arrive en partant d'une chaîne de if.

Panier if carte … else if twint … else if paypal … « interface » StrategiePaiement Carte Twint PayPal implémentent l'interface Facture Panier payer() utilise Panier inchangé
Étape 1 sur 6 · le problème

Le panier choisit le moyen de paiement avec une chaîne de if : tout est mélangé dans une seule méthode.

Étape 2 sur 6

Pour accepter PayPal, il faut rouvrir Panier et ajouter un else if : chaque nouveauté touche du code qui marchait.

Étape 3 sur 6 · une interface

On nomme ce qui varie, payer : l'interface StrategiePaiement déclare la méthode, sans dire comment.

Étape 4 sur 6 · une classe par stratégie

Carte, Twint et PayPal implémentent l'interface ; chacune reprend une seule branche du if.

Étape 5 sur 6 · le panier délègue

Panier garde une StrategiePaiement et appelle strategie.payer(c). Plus aucun if.

Étape 6 sur 6 · le gain

Payer sur facture ? On ajoute une classe Facture ; Panier ne change pas.

Question de tout à l'heure : faut-il modifier la classe Panier pour accepter un nouveau moyen de paiement ?

Non ? Le panier ne change pas ?

Exactement. Avec Strategy, on ajoute une classe Facture et le Panier ne bouge pas. Le code est ouvert à l'extension, fermé à la modification.
Exercice · à toi

Quel pattern ?

Range chaque situation sous le pattern qui y répond.

Vingt-trois, en une carte

La carte complète

Les 23 patterns du GoF

Cinq créationnels, sept structurels, onze comportementaux : 23 au total.1

5 créationnels 7 structurels 11 comportementaux

Une case par pattern

5 créationnels, 7 structurels, 11 comportementaux 5 + 7 + 11 = 23

La carte des 23

Fais défiler : les 23 patterns s'affichent un par un, famille par famille, avec un schéma, leur intention et un exemple concret. La mention « fiche » marque les cinq patterns détaillés plus haut. Les pastilles permettent de sauter directement à un pattern.

Scène 3 · Pattern 1 sur 23

Abstract Factory

Pour aller plus loin

Refactoring.Guru présente les patterns avec des diagrammes et du code dans plusieurs langages.3

Attention : son catalogue en compte 22, car il omet Interpreter ; le livre du Gang of Four en décrit 23.

refactoring.guru/design-patterns

Les pièges, puis l'essentiel

Attention

Les pièges classiques

Cinq erreurs qu'on voit souvent, chacune avec sa parade.

Deux façons d'échouer

type inconnu renvoie null plante plus loin type inconnu lève une exception erreur immédiate mieux vaut échouer tout de suite

Mettre des patterns partout

Un pattern répond à un problème précis. Ajouter une Factory ou un Singleton « pour faire propre » complique un code qui n'en avait pas besoin.

Le Singleton paresseux en multithread

Le test instance == null peut laisser passer deux fils à la fois : deux instances. Préfère un enum ou l'idiome du holder.

Une Factory qui renvoie null

Pour un type inconnu, mieux vaut lever une IllegalArgumentException tout de suite que laisser le client planter plus loin sur un null.

Oublier de se désabonner

Un observateur jamais détaché continue de recevoir les notifications et reste en mémoire : pense à detach() quand il n'est plus utile.

Confondre Factory simple et Factory Method

La Factory simple décide tout dans une seule méthode ; Factory Method confie le choix à des sous-classes ; Abstract Factory crée des familles d'objets assortis.

À retenir

La fiche en sept lignes

Design pattern

Une solution éprouvée et nommée à un problème de conception récurrent ; 23 dans le livre du GoF (1994).1

Trois familles

Créationnels (créer), structurels (assembler), comportementaux (collaborer).

Singleton

Une seule instance, un accès global ; en Java, de préférence un enum.

Factory

Le client demande, la fabrique choisit la classe ; un type inconnu lève une exception.

Observer

Le sujet prévient ses abonnés à chaque changement ; attach() et detach().

Builder

Des appels enchaînés (return this) puis build() ; idéal pour beaucoup de paramètres optionnels.

Strategy

Des algorithmes derrière une interface commune, choisis à l'exécution.

Quatorze questions pour finir

Quiz final

Teste-toi

Pour chaque situation, demande-toi d'abord : s'agit-il de créer, d'assembler ou de faire collaborer des objets ?

créer Singleton Factory Builder assembler Adapter Facade Decorator collaborer Observer Strategy Command demande-toi d'abord quelle famille

Sources

  1. Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides, Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994 (les 23 patterns, en trois familles), consulté le 8 octobre 2026. informit.com
  2. Joshua Bloch, Effective Java, 3e édition, Addison-Wesley, 2018, item 3 (Singleton par constructeur privé ou par enum), consulté le 8 octobre 2026. informit.com, code de l'item 3 (github.com)
  3. Refactoring.Guru, The Catalog of Design Patterns (22 patterns, sans Interpreter), consulté le 8 octobre 2026. refactoring.guru
  4. Oracle, HttpRequest (Java SE 25 & JDK 25), module java.net.http (HttpRequest.Builder), consulté le 8 octobre 2026. docs.oracle.com

Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026. Code Java des exemples compilé et exécuté avec Java 21.

Glisser pour continuer vers Graphes & Récursivité
Université