Modèles de conception en Java avec exemples de code

Patrons de conception en Java : guide complet avec exemples

Les patrons de conception (design patterns) sont des solutions éprouvées aux problèmes typiques rencontrés lors du développement de logiciels. En Java, ces modèles sont particulièrement prisés en raison du paradigme strictement orienté objet du langage. L'utilisation des patrons permet de rendre le code plus flexible, maintenable et évolutif.

Dans cet article, nous allons aborder les trois principaux groupes de patrons de conception en Java : les patrons de création, les patrons structurels et les patrons comportementaux. Chaque patron sera accompagné d'un exemple de code pratique.

Patrons de création (Creational Patterns)

Les patrons de création gèrent le processus de création des objets, rendant le système indépendant de la manière dont ils sont construits. Examinons deux des modèles les plus populaires : Singleton et Factory Method.

Singleton (Singleton)

Le Singleton garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global à celle-ci. Ce patron est souvent utilisé pour les connexions aux bases de données, la journalisation ou la mise en cache.

Exemple d'implémentation d'un Singleton thread-safe en Java :

public class DatabaseConnection {    private static volatile DatabaseConnection instance;    private String connectionString;

    private DatabaseConnection(String connectionString) {        this.connectionString = connectionString;    }

    public static DatabaseConnection getInstance(String connectionString) {        if (instance == null) {            synchronized (DatabaseConnection.class) {                if (instance == null) {                    instance = new DatabaseConnection(connectionString);                }            }        }        return instance;    }

    public void connect() {        System.out.println("Connexion à " + connectionString);    }}

Utilisation :

DatabaseConnection db = DatabaseConnection.getInstance("jdbc:mysql://localhost:3306/mydb");db.connect();

Factory Method (Méthode de fabrique)

Le Factory Method définit une interface pour créer un objet, mais permet aux sous-classes de modifier le type d'objet créé. Cela permet de déléguer la création d'instances aux classes filles.

Exemple d'une méthode de fabrique pour créer différents types de notifications :

interface Notification {    void send(String message);}

class EmailNotification implements Notification {    public void send(String message) {        System.out.println("Envoi d'email : " + message);    }}

class SMSNotification implements Notification {    public void send(String message) {        System.out.println("Envoi de SMS : " + message);    }}

abstract class NotificationFactory {    public abstract Notification createNotification();

    public void notifyUser(String message) {        Notification notification = createNotification();        notification.send(message);    }}

class EmailNotificationFactory extends NotificationFactory {    public Notification createNotification() {        return new EmailNotification();    }}

class SMSNotificationFactory extends NotificationFactory {    public Notification createNotification() {        return new SMSNotification();    }}

Utilisation :

NotificationFactory factory = new EmailNotificationFactory();factory.notifyUser("Votre commande est confirmée !");

Patrons structurels (Structural Patterns)

Les patrons structurels décrivent des moyens de combiner des classes et des objets pour former des structures plus grandes. Examinons le patron Adapter (Adaptateur).

Adapter (Adaptateur)

L'Adapter permet à des objets ayant des interfaces incompatibles de fonctionner ensemble. Il encapsule un objet en fournissant l'interface nécessaire au client.

Exemple d'un adaptateur pour intégrer un ancien système de journalisation