Bien sûr !
Voici un texte détaillé et explicatif sur les trois design patterns suivants : Pont
(Bridge), Singleton, et Patron de méthode (Template Method).
Je vais structurer ça proprement avec une définition claire, leur intérêt, leur structure et un
exemple pour chaque.
📌 1️⃣ Design Pattern PONT (Bridge)
📖 Définition :
Le pattern Bridge est un patron de conception structurel qui sépare l’abstraction d’une classe
de son implémentation, afin qu’elles puissent évoluer indépendamment l’une de l’autre.
Il est utile lorsque vous souhaitez découpler une hiérarchie d’abstraction et d’implémentation
pour éviter une explosion de classes en cas de combinaisons multiples.
📌 Pourquoi l’utiliser ?
• Séparer les responsabilités d’abstraction et d’implémentation.
• Favoriser l’extension indépendante de ces deux aspects.
• Réduire la complexité des hiérarchies de classes imbriquées.
📌 Structure :
• Abstraction : définit l’interface haut niveau et contient une référence vers
l’implémentation.
• Implémentation : interface ou classe abstraite pour les implémentations concrètes.
• RefinedAbstraction : spécialisation de l’abstraction.
• ConcreteImplementation : implémentation concrète de l’interface Implémentation.
📌 Exemple :
Imaginons un système de commandes qui doit fonctionner à la fois via API REST et via
WebSocket.
// Implémentation
interface CommunicationAPI {
void envoyerMessage(String message);
}
class RestAPI implements CommunicationAPI {
public void envoyerMessage(String message) {
System.out.println("Envoi via REST : " + message);
}
}
class WebSocketAPI implements CommunicationAPI {
public void envoyerMessage(String message) {
System.out.println("Envoi via WebSocket : " + message);
}
}
// Abstraction
abstract class Notification {
protected CommunicationAPI api;
public Notification(CommunicationAPI api) {
this.api = api;
}
abstract void notifier(String message);
}
// RefinedAbstraction
class Alerte extends Notification {
public Alerte(CommunicationAPI api) {
super(api);
}
public void notifier(String message) {
api.envoyerMessage("ALERTE : " + message);
}
}
// Utilisation
public class Main {
public static void main(String[] args) {
CommunicationAPI restAPI = new RestAPI();
Notification notification = new Alerte(restAPI);
notification.notifier("Erreur critique");
}
}
👉 Ici, Notification et CommunicationAPI évoluent séparément.
📌 2️⃣ Design Pattern SINGLETON
📖 Définition :
Le pattern Singleton est un patron de conception de création qui garantit qu’une classe ne
possède qu’une seule instance et fournit un point d’accès global à cette instance.
📌 Pourquoi l’utiliser ?
• Centraliser un objet utilisé globalement dans l’application (ex : logger, configuration,
gestionnaire de connexion à une base de données).
• Éviter la duplication de ressources critiques ou coûteuses.
📌 Structure :
• Instance privée statique
• Constructeur privé
• Méthode statique publique retournant l’instance
📌 Exemple :
En Java :
public class DatabaseConnection {
private static DatabaseConnection instance;
// Constructeur privé
private DatabaseConnection() {
System.out.println("Connexion à la base de données établie.");
}
// Méthode d'accès à l'instance
public static DatabaseConnection getInstance() {
if (instance == null) {
instance = new DatabaseConnection();
}
return instance;
}
public void query(String sql) {
System.out.println("Exécution : " + sql);
}
}
// Utilisation
public class Main {
public static void main(String[] args) {
DatabaseConnection connexion1 = DatabaseConnection.getInstance();
DatabaseConnection connexion2 = DatabaseConnection.getInstance();
connexion1.query("SELECT * FROM users");
// Les deux connexions pointent vers la même instance
System.out.println(connexion1 == connexion2); // true
}
}
👉 Ici, DatabaseConnection ne peut être instanciée qu’une seule fois.
📌 3️⃣ Design Pattern PATRON DE METHODE (Template
Method)
📖 Définition :
Le pattern Template Method est un patron de conception comportemental qui définit
l’ossature d’un algorithme dans une méthode d’une classe abstraite, et laisse certaines étapes à
la charge des sous-classes.
📌 Pourquoi l’utiliser ?
• Factoriser un comportement commun tout en laissant des étapes spécifiques
personnalisables.
• Faciliter le respect du principe DRY (Don’t Repeat Yourself).
• Contrôler l’ordre d’exécution des étapes d’un algorithme.
📌 Structure :
• Classe abstraite avec une méthode template qui appelle différentes étapes.
• Sous-classes qui redéfinissent certaines de ces étapes.
📌 Exemple :
Un système de génération de rapport.
abstract class Rapport {
// Méthode template
public final void generer() {
ouvrir();
ecrireContenu();
fermer();
}
protected void ouvrir() {
System.out.println("Ouverture du rapport");
}
protected abstract void ecrireContenu();
protected void fermer() {
System.out.println("Fermeture du rapport");
}
}
class RapportPDF extends Rapport {
protected void ecrireContenu() {
System.out.println("Contenu PDF du rapport");
}
}
class RapportWord extends Rapport {
protected void ecrireContenu() {
System.out.println("Contenu Word du rapport");
}
}
// Utilisation
public class Main {
public static void main(String[] args) {
Rapport rapport = new RapportPDF();
rapport.generer();
Rapport rapport2 = new RapportWord();
rapport2.generer();
}
}
👉 Le squelette de la méthode generer() est commun, seules les étapes spécifiques varient.
📊 Conclusion
Design Pattern Type Usage principal
Séparer abstraction et implémentation pour
PONT (Bridge) Structurel
évolution indépendante.
Garantir l’existence d’une seule instance accessible
SINGLETON Créationnel
globalement.
PATRON DE Définir l’ossature d’un algorithme et déléguer
Comportemental
METHODE certaines étapes aux sous-classes.
Si tu veux, je peux aussi te faire un schéma UML pour chaque, ou leur version en TypeScript,
Python ou PHP pour compléter. Tu veux ? 👌
