Patrons de conception en Java avec exemples : de A à Z

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, en tant que langage orienté objet fortement typé, les patrons sont particulièrement efficaces. Ils aident à rendre le code flexible, réutilisable et facile à maintenir. Dans cet article, nous analyserons les trois principaux groupes de patrons (selon la classification GoF) : de création, structurels et comportementaux — avec des exemples concrets en Java.

1. Patrons de création (Creational Patterns)

Ces patrons gèrent le processus de création des objets, rendant le système indépendant de la manière dont les objets sont créés, composés et représentés.

1.1. Singleton (Singleton)

Garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global à celle-ci. Un exemple classique est le pool de connexions à une base de données ou un logger.

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("Connected to: " + connectionString);    }}

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

1.2. Factory Method (Méthode de fabrique)

Définit une interface pour créer un objet, mais permet aux sous-classes de modifier le type d'objet créé. Idéal lorsque le type exact de l'objet n'est pas connu à l'avance.

interface Transport {    void deliver();}

class Truck implements Transport {    public void deliver() { System.out.println("Livraison par camion sur terre"); }}

class Ship implements Transport {    public void deliver() { System.out.println("Livraison par bateau en mer"); }}

abstract class Logistics {    abstract Transport createTransport();        public void planDelivery() {        Transport t = createTransport();        t.deliver();    }}

class RoadLogistics extends Logistics {    Transport createTransport() { return new Truck(); }}

class SeaLogistics extends Logistics {    Transport createTransport() { return new Ship(); }}

// UtilisationLogistics logistics = new RoadLogistics();logistics.planDelivery(); // Sortie : Livraison par camion sur terre

2. Patrons structurels (Structural Patterns)

Ils sont responsables de la composition des classes et des objets, aidant à construire des structures complexes à partir de composants simples.

2.1. Adapter (Adaptateur)

Permet à des objets avec des interfaces incompatibles de fonctionner ensemble. Souvent utilisé pour intégrer du code ancien (legacy) avec du nouveau.

// Ancienne interfaceinterface OldSystem {    String getDataInXML();}

// Nouvelle interfaceinterface NewSystem {    String getDataInJSON();}

// Implémentation de l'ancien systèmeclass LegacySystem implements OldSystem {    public String getDataInXML() { return "<data>Hello</data>"; }}

// Adaptateurclass XMLToJSONAdapter implements NewSystem {    private OldSystem oldSystem;        public XMLToJSONAdapter(OldSystem oldSystem) {        this.oldSystem = oldSystem;    }        public String getDataInJSON() {        String xml = oldSystem.getDataInXML();        return "{\\"data\\": \\"" + xml.replaceAll("<.*?>", "") + "\\"}";    }}

// E