Cos'è il pattern di progettazione 'Builder'…

Il pattern "Builder" (Costruttore) è un pattern creazionale che consente di creare oggetti complessi passo dopo passo, offrendo diverse opzioni di configurazione.

Scopo: Separare il processo di costruzione di un oggetto dalla sua rappresentazione. Permette di ottenere diverse rappresentazioni dello stesso processo di costruzione.
Vantaggi:
- Permette di costruire un oggetto passo dopo passo, nascondendo i dettagli della costruzione.
- Facilita la creazione di oggetti con un gran numero di parametri opzionali (a differenza dei costruttori con molti argomenti o dell'anti-pattern Telescoping Constructors).
- Lo stesso codice di costruzione può essere usato per creare diverse rappresentazioni dell'oggetto.
Principali partecipanti:
1. Builder (Costruttore): Interfaccia o classe astratta che definisce i passaggi per costruire le parti dell’oggetto.
2. ConcreteBuilder (Costruttore Concreto): Implementazione dell’interfaccia Builder, che crea parti specifiche dell’oggetto e fornisce un metodo per ottenere il risultato finale.
3. Director (Direttore): Definisce la sequenza di passaggi per creare l’oggetto, usando un oggetto Builder. Il Direttore è opzionale e il cliente può lavorare direttamente con il Builder.
4. Product (Prodotto): L’oggetto che si sta costruendo.

Esempio di struttura (Java):

// Prodotto
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 + "]";
    }
}

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

// Costruttore Concreto
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;
    }
}

// Direttore (Opzionale)
class CarDirector {
    private CarBuilder builder;

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

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

// Uso del cliente
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);

        // Uso diretto senza Direttore
        CarBuilder anotherSportsCarBuilder = new SportsCarBuilder();
        anotherSportsCarBuilder.buildEngine();
        anotherSportsCarBuilder.buildColor(); // Costruzione senza ruote
        Car partialCar = anotherSportsCarBuilder.getResult();
        System.out.println("Built partial car: " + partialCar);
    }
}

Cos'è il pattern di progettazione 'Builder' (Builder)?