Was ist ein Builder im Kontext der…

Entwurfsmuster, das die Konstruktion eines komplexen Objekts von seiner Darstellung trennt, sodass verschiedene Darstellungen desselben Bauprozesses erstellt werden können.

Hauptmerkmale:

Aufgabentrennung: Die Logik zur Erstellung des Objekts (Bauabschnitte) und die Darstellung des Objekts (Endprodukt) sind getrennt.
Schrittweise Konstruktion: Das Objekt wird Schritt für Schritt gebaut, was den Prozess flexibler und verständlicher macht.
Verschiedene Darstellungen: Der gleiche Bauprozess kann verwendet werden, um verschiedene Variationen des Objekts zu erstellen.
Kapselung: Die Details der Objekterstellung sind vor dem Kunden verborgen, was die Nutzung vereinfacht.

Hauptakteure:

Builder (Erbauer): Abstrakte Schnittstelle oder Klasse, die die Schritte zur Erstellung von Teilen des Produkts definiert.
ConcreteBuilder (Konkreter Erbauer): Konkrete Implementierung des Erbauers, die die tatsächliche Konstruktion der Teile des Produkts durchführt und das Ergebnis speichert.
Director (Direktor): Klasse, die ein ConcreteBuilder-Objekt verwendet, um das Produkt zu konstruieren, indem sie die entsprechenden Methoden in einer bestimmten Reihenfolge aufruft.
Product (Produkt): Das komplexe Objekt, das gebaut wird.

Beispiel:

Erstellung eines Pizza-Objekts mit verschiedenen Zutaten:

// Produkt
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 mit Teig: " + dough + ", Soße: " + sauce + ", Käse: " + cheese + ", Toppings: " + toppings;
    }
}

// Builder-Schnittstelle
interface PizzaBuilder {
    void buildDough();
    void buildSauce();
    void buildCheese();
    void addTopping(String topping);
    Pizza getResult();
}

// Konkreter Builder
class MargheritaPizzaBuilder implements PizzaBuilder {
    private Pizza pizza;

    public MargheritaPizzaBuilder() {
        this.pizza = new Pizza();
    }

    @Override
    public void buildDough() {
        pizza.setDough("Dünner Teig");
    }

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

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

    @Override
    public void addTopping(String topping) {
        // Margherita hat standardmäßig keine zusätzlichen Toppings
    }

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

// Direktor
class Cook {
    private PizzaBuilder pizzaBuilder;

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

    public void constructPizza() {
        pizzaBuilder.buildDough();
        pizzaBuilder.buildSauce();
        pizzaBuilder.buildCheese();
        // Zusätzliche Toppings können hier basierend auf Pizzatyp oder Anforderungen hinzugefügt werden
    }
}

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

Anwendung bei:

Notwendigkeit, ein komplexes Objekt mit vielen optionalen Parametern zu erstellen.
Der Erstellungsprozess des Objekts ist sequenziell und umfasst mehrere Schritte.
Verschiedene Variationen desselben Objekts sollen mit demselben Baualgorithmus erstellt werden.
Vermeidung eines Konstruktors mit vielen Parametern ("telescoping constructor").

Vorteile:

Verbessert die Lesbarkeit und Wartbarkeit des Codes.
Bietet Flexibilität bei der Objekterstellung.
Ermöglicht die Erstellung unveränderlicher Objekte.
Eliminierung der Notwendigkeit vieler Konstruktoren.

Nachteile:

Kann die Anzahl der Klassen im Projekt erhöhen (für jeden Objekttyp und jeden Erbauer).
Erfordert anfänglichen Designaufwand.

Was ist ein Builder im Kontext der Softwareentwicklung?