Cos'è un Builder nel contesto della progettazione del…

Questo è un pattern di progettazione creazionale che separa la costruzione di un oggetto complesso dalla sua rappresentazione, consentendo di creare diverse rappresentazioni dell'oggetto utilizzando lo stesso processo di costruzione.

Principio di funzionamento:

Prodotto (Product): Oggetto complesso da costruire.
Costruttore (Builder): Interfaccia astratta per creare parti del prodotto.
Costruttore Concreto (Concrete Builder): Implementazione dell'interfaccia "Builder" che crea parti specifiche del prodotto e le assembla in un prodotto finale.
Direttore (opzionale): Definisce la sequenza di passaggi per la costruzione e utilizza il Costruttore per creare il prodotto.

Vantaggi:

Permette di costruire oggetti complessi passo dopo passo.
Separa la logica di costruzione dall'oggetto stesso.
Permette di creare diverse rappresentazioni dell'oggetto con lo stesso processo.
Facilita l'estensione aggiungendo nuovi Costruttori Concreti.

Svantaggi:

Aumenta il numero di classi a causa della necessità di creare diversi Costruttori Concreti.
Può complicare il codice per oggetti semplici.

Esempio di utilizzo (Java):

Immaginiamo la creazione di un oggetto complesso "Casa":

// Prodotto
class House {
    private String walls;
    private String roof;
    private String windows;
    private String doors;

    public void setWalls(String walls) { this.walls = walls; }
    public void setRoof(String roof) { this.roof = roof; }
    public void setWindows(String windows) { this.windows = windows; }
    public void setDoors(String doors) { this.doors = doors; }

    @Override
    public String toString() {
        return "House{" +
               "walls='" + walls + '\'' +
               ", roof='" + roof + '\'' +
               ", windows='" + windows + '\'' +
               ", doors='" + doors + '\'' +
               '}';
    }
}

// Costruttore
interface HouseBuilder {
    void buildWalls();
    void buildRoof();
    void buildWindows();
    void buildDoors();
    House getResult();
}

// Costruttore Concreto
class StoneHouseBuilder implements HouseBuilder {
    private House house;

    public StoneHouseBuilder() {
        this.house = new House();
    }

    @Override
    public void buildWalls() {
        house.setWalls("Muri di pietra");
    }

    @Override
    public void buildRoof() {
        house.setRoof("Tetto di tegole");
    }

    @Override
    public void buildWindows() {
        house.setWindows("Finestre di legno");
    }

    @Override
    public void buildDoors() {
        house.setDoors("Porta di legno massiccio");
    }

    @Override
    public House getResult() {
        return house;
    }
}

// Direttore (opzionale)
class Director {
    public void constructStoneHouse(HouseBuilder builder) {
        builder.buildWalls();
        builder.buildRoof();
        builder.buildWindows();
        builder.buildDoors();
    }
}

// Utilizzo
public class BuilderExample {
    public static void main(String[] args) {
        Director director = new Director();
        HouseBuilder stoneHouseBuilder = new StoneHouseBuilder();

        director.constructStoneHouse(stoneHouseBuilder);

        House stoneHouse = stoneHouseBuilder.getResult();
        System.out.println(stoneHouse); // Output: House{walls='Muri di pietra', roof='Tetto di tegole', windows='Finestre di legno', doors='Porta di legno massiccio'}
    }
}

Cos'è un Builder nel contesto della progettazione del software?