Qu'est-ce que le patron de conception 'Constructeur'…

Le patron "Builder" (Constructeur) est un patron de conception créatif qui permet de créer des objets complexes étape par étape, en fournissant différentes options de configuration.

Objectif : Séparer le processus de construction d’un objet de sa représentation. Permet d’obtenir différentes représentations du même processus de construction.
Avantages :
- Permet de construire un objet étape par étape, en cachant les détails de la construction.
- Facilite la création d’objets avec un grand nombre de paramètres optionnels (contrairement aux constructeurs avec plusieurs arguments ou au anti-pattern Telescoping Constructors).
- Le même code de construction peut être utilisé pour créer différentes représentations de l’objet.
Participants principaux :
1. Builder (Constructeur) : Interface ou classe abstraite définissant les étapes de construction des parties de l’objet.
2. ConcreteBuilder (Constructeur Concret) : Implémentation de l’interface Builder, créant des parties spécifiques de l’objet et fournissant une méthode pour obtenir le résultat final.
3. Director (Réalisateur) : Définit la séquence d’étapes pour créer l’objet, en utilisant un objet Builder. Le Réalisateur est optionnel et le client peut travailler directement avec le Builder.
4. Product (Produit) : L’objet construit.

Exemple de structure (Java) :

// Produit
class Car {
    private String engine;
    private int wheels;
    private String color;

    public void setEngine(String engine) {
        this.engine = engine;
    }

    public void setWheels(int wheels) {
        this.wheels = wheels;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Car [engine=" + engine + ", wheels=" + wheels + ", color=" + color + "]";
    }
}

// Interface Builder
interface CarBuilder {
    void buildEngine();
    void buildWheels();
    void buildColor();
    Car getResult();
}

// ConcreteBuilder
class SportsCarBuilder implements CarBuilder {
    private Car car = new Car();

    @Override
    public void buildEngine() {
        car.setEngine("V8");
    }

    @Override
    public void buildWheels() {
        car.setWheels(4);
    }

    @Override
    public void buildColor() {
        car.setColor("Red");
    }

    @Override
    public Car getResult() {
        return car;
    }
}

// Director (Optionnel)
class CarDirector {
    private CarBuilder builder;

    public CarDirector(CarBuilder builder) {
        this.builder = builder;
    }

    public void constructCar() {
        builder.buildEngine();
        builder.buildWheels();
        builder.buildColor();
    }
}

// Utilisation client
public class Client {
    public static void main(String[] args) {
        CarBuilder sportsCarBuilder = new SportsCarBuilder();
        CarDirector director = new CarDirector(sportsCarBuilder);

        director.constructCar();
        Car sportsCar = sportsCarBuilder.getResult();
        System.out.println("Built car: " + sportsCar);

        // Utilisation directe sans Réalisateur
        CarBuilder anotherSportsCarBuilder = new SportsCarBuilder();
        anotherSportsCarBuilder.buildEngine();
        anotherSportsCarBuilder.buildColor(); // Construction sans roues
        Car partialCar = anotherSportsCarBuilder.getResult();
        System.out.println("Built partial car: " + partialCar);
    }
}

Qu'est-ce que le patron de conception 'Constructeur' (Builder) ?