Wat is een Builder in de context van softwareontwerp…

Dit is een creational design pattern dat het bouwen van een complex object scheidt van de representatie ervan, waardoor verschillende representaties van het object kunnen worden gemaakt met hetzelfde bouwproces.

Werking:

Product (Product): Complex object dat gebouwd moet worden.
Builder: Abstracte interface voor het maken van delen van het product.
Concrete Builder: Implementatie van de "Builder"-interface die specifieke delen van het product maakt en deze samenvoegt tot een eindproduct.
Director (optioneel): Bepaalt de volgorde van bouwstappen en gebruikt de Builder om het product te maken.

Voordelen:

Maakt het mogelijk om complexe objecten stapsgewijs te bouwen.
Scheidt de bouwlogica van het object zelf.
Maakt het mogelijk om verschillende representaties van het object te creëren met hetzelfde proces.
Gemakkelijk uit te breiden door nieuwe Concrete Builders toe te voegen.

Nadelen:

Verhoogt het aantal klassen vanwege de noodzaak om verschillende Concrete Builders te maken.
Kan de code voor eenvoudige objecten compliceren.

Voorbeeld (Java):

Stel je voor dat we een complex object "Huis" maken:

// Product
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 + '\'' +
               '}';
    }
}

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

// Concrete Builder
class StoneHouseBuilder implements HouseBuilder {
    private House house;

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

    @Override
    public void buildWalls() {
        house.setWalls("Stenen muren");
    }

    @Override
    public void buildRoof() {
        house.setRoof("Dakpannen");
    }

    @Override
    public void buildWindows() {
        house.setWindows("Houten ramen");
    }

    @Override
    public void buildDoors() {
        house.setDoors("Stevige houten deuren");
    }

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

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

// Gebruik
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); // Uitvoer: House{walls='Stenen muren', roof='Dakpannen', windows='Houten ramen', doors='Stevige houten deuren'}
    }
}

Wat is een Builder in de context van softwareontwerp?