Wat is een builder in de context van…

Het ontwerppatroon dat het construeren van een complex object loskoppelt van de presentatie ervan, waardoor het mogelijk is verschillende presentaties van hetzelfde bouwproces te creëren.

Belangrijke kenmerken:

Verantwoordelijkheidsscheiding: De logica voor het maken van het object (bouwstappen) en de presentatie van het object (het resulterende product) zijn gescheiden.
Stapsgewijs bouwen: Het object wordt stap voor stap gebouwd, wat het proces flexibeler en begrijpelijker maakt.
Verschillende presentaties: Hetzelfde bouwproces kan worden gebruikt om verschillende variaties van het object te maken.
Incapsulatie: Details van het maken van het object zijn verborgen voor de klant, wat het gebruik vereenvoudigt.

Belangrijke deelnemers:

Builder (Bouwer): Abstracte interface of klasse die de stappen definieert voor het maken van onderdelen van het product.
ConcreteBuilder (Concrete Bouwer): Concrete implementatie van de Bouwer die daadwerkelijk de onderdelen van het product bouwt en het resultaat opslaat.
Director (Regisseur): Klasse die het ConcreteBuilder-object gebruikt om het product te construeren, door de juiste bouwmethoden aan te roepen in een bepaalde volgorde.
Product (Product): Het complexe object dat wordt gebouwd.

Voorbeeld van gebruik:

Het maken van een Pizza object met verschillende ingrediënten:

// Product
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 met deeg: " + dough + ", saus: " + sauce + ", kaas: " + cheese + ", toppings: " + toppings;
    }
}

// Builder interface
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("Dunne korst");
    }

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

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

    @Override
    public void addTopping(String topping) {
        // Margherita heeft standaard geen extra toppings
    }

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

// Director
class Cook {
    private PizzaBuilder pizzaBuilder;

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

    public void constructPizza() {
        pizzaBuilder.buildDough();
        pizzaBuilder.buildSauce();
        pizzaBuilder.buildCheese();
        // Extra toppings kunnen hier worden toegevoegd op basis van type of vereisten
    }
}

// Client code
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);
    }
}

Toepassing wanneer:

Het is nodig om een complex object te maken met veel optionele parameters.
Het maakproces is sequentieel en omvat meerdere stappen.
Verschillende variaties van hetzelfde object moeten worden gemaakt met hetzelfde constructie-algoritme.
Het vermijden van een constructor met veel parameters ("telescoping constructor").

Voordelen:

Verbetert de leesbaarheid en onderhoudbaarheid van de code.
Biedt flexibiliteit bij het maken van objecten.
Maakt het mogelijk om onveranderlijke objecten te creëren.
Vermijdt het gebruik van veel constructeurs.

Nadelen:

Kan het aantal klassen in het project vergroten (voor elk type object en elke bouwer).
Vereist enige initiële ontwerpinspanning.

Wat is een builder in de context van softwareontwikkeling?