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.
Informatique · Conception
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 quizLe principe
Une solution éprouvée à un problème qui revient, avec un nom. On l'adapte à chaque projet.
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
Le plan
Oui, non ? Je ne sais pas encore.
Une solution qui a un nom
Introduction
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.
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.
Une seule instance, partout
Pattern 1 · Créationnel
Une seule instance de la classe dans toute l'application (définition), avec un point d'accès global.
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.
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
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
Créer des objets sans spécifier leur classe exacte : le client demande un « chien », la fabrique choisit la classe.
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
Fais défiler : trois appels à la fabrique, trois objets différents sur le tapis.
createAnimal("dog")
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).
Un changement, plusieurs à prévenir
Pattern 3 · Comportemental
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.
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
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.
Trois abonnés
abonnés A, B, C
Donc il ne reçoit rien tant qu'il n'est pas réabonné ?
Construire pas à pas
Pattern 4 · Créationnel
Construire des objets complexes étape par étape, au lieu d'un constructeur à rallonge dont on confond les paramètres.
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()
Échanger un algorithme
Pattern 5 · Comportemental
Chaque algorithme vit dans sa propre classe, derrière une interface commune, et on choisit lequel utiliser à l'exécution.
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
Fais défiler : voici comment on y arrive en partant d'une chaîne de if.
Le panier choisit le moyen de paiement avec une chaîne de if : tout est mélangé dans une seule méthode.
Pour accepter PayPal, il faut rouvrir Panier et ajouter un else if : chaque nouveauté touche du code qui marchait.
On nomme ce qui varie, payer : l'interface StrategiePaiement déclare la méthode, sans dire comment.
Carte, Twint et PayPal implémentent l'interface ; chacune reprend une seule branche du if.
Panier garde une StrategiePaiement et appelle strategie.payer(c). Plus aucun if.
Payer sur facture ? On ajoute une classe Facture ; Panier ne change pas.
Non ? Le panier ne change pas ?
Range chaque situation sous le pattern qui y répond.
Vingt-trois, en une carte
La carte complète
Cinq créationnels, sept structurels, onze comportementaux : 23 au total.1
Une case par pattern
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.
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.
Les pièges, puis l'essentiel
Attention
Cinq erreurs qu'on voit souvent, chacune avec sa parade.
Deux façons d'échouer
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 test instance == null peut laisser passer deux fils à la fois : deux instances. Préfère un enum ou l'idiome du holder.
Pour un type inconnu, mieux vaut lever une IllegalArgumentException tout de suite que laisser le client planter plus loin sur un null.
Un observateur jamais détaché continue de recevoir les notifications et reste en mémoire : pense à detach() quand il n'est plus utile.
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
Une solution éprouvée et nommée à un problème de conception récurrent ; 23 dans le livre du GoF (1994).1
Créationnels (créer), structurels (assembler), comportementaux (collaborer).
Une seule instance, un accès global ; en Java, de préférence un enum.
Le client demande, la fabrique choisit la classe ; un type inconnu lève une exception.
Le sujet prévient ses abonnés à chaque changement ; attach() et detach().
Des appels enchaînés (return this) puis build() ; idéal pour beaucoup de paramètres optionnels.
Des algorithmes derrière une interface commune, choisis à l'exécution.
Quatorze questions pour finir
Quiz final
Pour chaque situation, demande-toi d'abord : s'agit-il de créer, d'assembler ou de faire collaborer des objets ?
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.