Cours Résumé sur les Design Patterns
Introduction
Un Design Pattern est une solution standardisée pour résoudre des problèmes récurrents
en développement logiciel. Ils permettent de structurer le code pour le rendre réutilisable,
maintenable et modulable.
1. Singleton
Définition : Le Singleton garantit qu'une classe n'a qu'une seule instance et fournit un point
d'accès global à cette instance. C'est un patron de conception qui garantit qu'une classe n'a
qu'une seule instance et fournit un point d'accès global à cette instance. Ce pattern est
souvent utilisé pour gérer des ressources partagées, telles qu'une connexion à une base de
données ou un gestionnaire de configuration, où il est essentiel de s'assurer qu'il n'y a
qu'une seule instance en cours d'exécution.
Fonctionnement :
- Une variable statique stocke l'instance unique.
- Un constructeur privé empêche la création de nouvelles instances.
- Une méthode publique fournit l'accès à l'instance.
Création de l'Instance : La classe de connexion à la base de données crée une instance
de la connexion la première fois qu'elle est demandée.
Accès Global : Les autres parties de l'application peuvent accéder à cette instance unique
sans en créer de nouvelles.
Cas d'utilisation :
- Gestionnaire de configuration.
- Gestionnaire de connexion à une base de données.
Exemple terre-à-terre : Imaginez un directeur d'école. Peu importe qui demande, il n'existe
qu'un seul directeur.
Code :
public class SchoolDirector {
private static SchoolDirector instance; // Instance unique
private SchoolDirector() {
System.out.println("Directeur nommé !");
}
public static SchoolDirector getInstance() {
if (instance == null) {
instance = new SchoolDirector();
}
return instance;
}
}
// Test
public class Main {
public static void main(String[] args) {
SchoolDirector director1 = SchoolDirector.getInstance();
SchoolDirector director2 = SchoolDirector.getInstance();
System.out.println(director1 == director2); // true : même instance
}
}
2. Strategy
Définition : Le pattern Strategy permet de définir une famille d'algorithmes, de les
encapsuler et de les rendre interchangeables dynamiquement.
Fonctionnement :
- Une interface définit les méthodes communes des stratégies.
- Les classes concrètes implémentent les différentes stratégies.
- Une classe contextuelle utilise ces stratégies.
Cas d'utilisation :
- Calcul de promotions ou réductions dans un système de facturation.
- Choix d'une méthode de transport.
Exemple terre-à-terre : Un livreur choisit de livrer en voiture, vélo ou à pied selon les
conditions.
Code :
// Interface Strategy
interface DeliveryStrategy {
String deliver();
}
// Implémentations concrètes
class CarDelivery implements DeliveryStrategy {
public String deliver() {
return "Livraison en voiture.";
}
}
class BikeDelivery implements DeliveryStrategy {
public String deliver() {
return "Livraison en vélo.";
}
}
class FootDelivery implements DeliveryStrategy {
public String deliver() {
return "Livraison à pied.";
}
}
// Contexte
class DeliveryContext {
private DeliveryStrategy strategy;
public void setStrategy(DeliveryStrategy strategy) {
this.strategy = strategy;
}
public void deliver() {
System.out.println(strategy.deliver());
}
}
// Test
public class Main {
public static void main(String[] args) {
DeliveryContext context = new DeliveryContext();
context.setStrategy(new CarDelivery());
context.deliver(); // Livraison en voiture.
context.setStrategy(new BikeDelivery());
context.deliver(); // Livraison en vélo.
}
}
3. Observer
Définition : L'Observer permet de notifier automatiquement un ensemble d'objets lorsqu'un
état change dans un autre objet. C'est un patron de conception qui permet à un objet, appelé
le sujet, de notifier automatiquement d'autres objets, appelés observateurs, lorsqu'il y a un
changement d'état. Ce pattern est couramment utilisé dans la gestion des événements, où
plusieurs composants doivent réagir à des changements dans un autre composant.
Fonctionnement :
- Le sujet conserve une liste d'observateurs.
- Lorsque son état change, il informe tous les observateurs.
Lorsque la température change (par exemple, il fait plus chaud), l'application météo (sujet)
doit informer tous les afficheurs (observateurs) de ce changement
Cas d'utilisation :
- Notifications en temps réel, comme des alertes de prix sur un site.
- Chaînes YouTube où les abonnés reçoivent des notifications.
Exemple terre-à-terre : Une chaîne YouTube informe ses abonnés lorsqu'une nouvelle vidéo
est publiée.
Code :
import java.util.ArrayList;
import java.util.List;
// Sujet
class YouTubeChannel {
private List<Subscriber> subscribers = new ArrayList<>();
public void subscribe(Subscriber subscriber) {
subscribers.add(subscriber);
}
public void notifySubscribers(String video) {
for (Subscriber s : subscribers) {
s.update(video);
}
}
}
// Observateur
class Subscriber {
private String name;
public Subscriber(String name) {
this.name = name;
}
public void update(String video) {
System.out.println(name + " a reçu une notification : " + video);
}
}
// Test
public class Main {
public static void main(String[] args) {
YouTubeChannel channel = new YouTubeChannel();
Subscriber alice = new Subscriber("Alice");
Subscriber bob = new Subscriber("Bob");
channel.subscribe(alice);
channel.subscribe(bob);
channel.notifySubscribers("Nouvelle vidéo publiée !");
}
}
4. Factory
Définition : La Factory simplifie la création d'objets en centralisant leur logique de création.
Fonctionnement :
- Une classe factory encapsule la logique de création des objets.
- L'utilisateur demande à la factory de créer un objet sans connaître ses détails internes.
Cas d'utilisation :
- Création d'objets complexes ou avec de nombreuses dépendances.
- Création conditionnelle d'objets.
Exemple terre-à-terre : Dans un restaurant, le client commande une pizza sans savoir
comment elle est préparée.
Code :
class Pizza {
private String type;
public Pizza(String type) {
this.type = type;
}
public String getType() {
return type;
}
}
class PizzaFactory {
public static Pizza createPizza(String type) {
return new Pizza(type);
}
}
// Test
public class Main {
public static void main(String[] args) {
Pizza pizza = PizzaFactory.createPizza("Margherita");
System.out.println("Pizza commandée : " + pizza.getType());
}
}
Le Pattern Adapter
Description
Le pattern Adapter est un modèle de conception qui permet à des interfaces incompatibles
de fonctionner ensemble. En d'autres termes, il sert de pont entre deux systèmes ou classes
qui ne peuvent pas interagir directement en raison de différences dans leurs interfaces.
Exemple en Java :
interface Target {
void request();
class Adaptee {
void specificRequest() {
System.out.println("Appel de la méthode spécifique.");
class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
public void request() {
adaptee.specificRequest();
}
Explication :
• interface Target : Définit l'interface que le client utilise.
• class Adaptee : C'est une classe qui a une méthode spécifique que le client ne
peut pas utiliser directement.
• class Adapter : Implémente l'interface Target et contient une instance de
Adaptee. Dans la méthode request(), elle appelle la méthode
specificRequest() de Adaptee, permettant ainsi au client d'utiliser cette
méthode via l'interface Target.
