Qu'est-ce qu'un constructeur (Builder) dans le…

Le patron de conception qui sépare la construction d’un objet complexe de sa représentation, permettant de créer différentes représentations du même processus de construction.

Caractéristiques clés:

Séparation des responsabilités: La logique de création de l’objet (étapes de construction) et la représentation de l’objet (produit final) sont séparées.
Construction étape par étape: L’objet est construit étape par étape, ce qui rend le processus plus flexible et compréhensible.
Différentes représentations: Le même processus de construction peut être utilisé pour créer différentes variations de l’objet.
Encapsulation: Les détails de la création de l’objet sont cachés au client, ce qui simplifie son utilisation.

Participants principaux:

Builder (Constructeur): Interface ou classe abstraite définissant les étapes pour créer des parties du produit.
ConcreteBuilder (Constructeur Concret): Implémentation concrète du constructeur, effectuant la construction réelle des parties du produit et stockant le résultat.
Director (Réalisateur): Classe utilisant un objet ConcreteBuilder pour construire le produit, en appelant les méthodes appropriées dans une séquence déterminée.
Product (Produit): Objet complexe en cours de construction.

Exemple d’utilisation:

Création d’un objet Pizza avec différents ingrédients:

// Produit
class Pizza {
    private String dough;
    private String sauce;
    private String cheese;
    private List<String> toppings;

    public void setDough(String dough) { this.dough = dough; }
    public void setSauce(String sauce) { this.sauce = sauce; }
    public void setCheese(String cheese) { this.cheese = cheese; }
    public void addTopping(String topping) {
        if (toppings == null) {
            toppings = new ArrayList<>();
        }
        toppings.add(topping);
    }

    @Override
    public String toString() {
        return "Pizza avec pâte: " + dough + ", sauce: " + sauce + ", fromage: " + cheese + ", toppings: " + toppings;
    }
}

// Interface du Builder
interface PizzaBuilder {
    void buildDough();
    void buildSauce();
    void buildCheese();
    void addTopping(String topping);
    Pizza getResult();
}

// ConcreteBuilder
class MargheritaPizzaBuilder implements PizzaBuilder {
    private Pizza pizza;

    public MargheritaPizzaBuilder() {
        this.pizza = new Pizza();
    }

    @Override
    public void buildDough() {
        pizza.setDough("Croûte fine");
    }

    @Override
    public void buildSauce() {
        pizza.setSauce("Sauce tomate");
    }

    @Override
    public void buildCheese() {
        pizza.setCheese("Mozzarella");
    }

    @Override
    public void addTopping(String topping) {
        // La Margherita n’a pas de toppings supplémentaires par défaut
    }

    @Override
    public Pizza getResult() {
        return pizza;
    }
}

// Réalisateur
class Cook {
    private PizzaBuilder pizzaBuilder;

    public void setPizzaBuilder(PizzaBuilder pb) {
        pizzaBuilder = pb;
    }

    public void constructPizza() {
        pizzaBuilder.buildDough();
        pizzaBuilder.buildSauce();
        pizzaBuilder.buildCheese();
        // Des toppings supplémentaires peuvent être ajoutés ici en fonction du type de pizza ou des exigences
    }
}

// Code client
public class PizzaShop {
    public static void main(String[] args) {
        Cook cook = new Cook();
        PizzaBuilder margheritaBuilder = new MargheritaPizzaBuilder();

        cook.setPizzaBuilder(margheritaBuilder);
        cook.constructPizza();

        Pizza pizza = margheritaBuilder.getResult();
        System.out.println(pizza);
    }
}

Appliqué lorsque:

Il est nécessaire de créer un objet complexe avec de nombreux paramètres optionnels.
Le processus de création de l’objet est séquentiel et comprend plusieurs étapes.
Il faut créer différentes variations du même objet en utilisant le même algorithme de construction.
Il faut éviter un constructeur avec un grand nombre de paramètres ("constructeur télescopique").

Avantages:

Améliore la lisibilité et la maintenabilité du code.
Offre une flexibilité dans la création d’objets.
Permet de créer des objets immuables.
Élimine la nécessité de nombreux constructeurs.

Inconvénients:

Peut augmenter le nombre de classes dans le projet (pour chaque type d’objet et chaque constructeur).
Nécessite un effort initial en conception.

Qu'est-ce qu'un constructeur (Builder) dans le contexte du développement logiciel ?