Czym jest Builder w kontekście projektowania…

To jest wzorzec projektowy kreacyjny, który oddziela konstruowanie złożonego obiektu od jego reprezentacji, umożliwiając tworzenie różnych reprezentacji obiektu przy użyciu tego samego procesu konstruowania.

Zasada działania:

Produkt (Product): Złożony obiekt, który ma zostać zbudowany.
Budowniczy (Builder): Abstrytny interfejs do tworzenia części produktu.
Konkretna Budowniczy (Concrete Builder): Implementacja interfejsu "Builder", która tworzy konkretne części produktu i składa je w gotowy produkt.
Reżyser (Director, opcjonalnie): Określa kolejność kroków konstruowania i używa Budowniczego do tworzenia produktu.

Zalety:

Pozwala na stopniowe konstruowanie złożonych obiektów.
Oddziela logikę budowania od samego obiektu.
Umożliwia tworzenie różnych reprezentacji obiektu za pomocą tego samego procesu.
Ułatwia rozbudowę poprzez dodanie nowych Konkretów Budowniczych.

Wady:

Zwiększa liczbę klas z powodu konieczności tworzenia osobnych Konkretów Budowniczych.
Może skomplikować kod dla prostych obiektów.

Przykład użycia (Java):

Wyobraźmy sobie tworzenie złożonego obiektu "Dom":

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

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

// Konkretna Budowniczy
class StoneHouseBuilder implements HouseBuilder {
    private House house;

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

    @Override
    public void buildWalls() {
        house.setWalls("Kamienne ściany");
    }

    @Override
    public void buildRoof() {
        house.setRoof("Tynk z dachówki");
    }

    @Override
    public void buildWindows() {
        house.setWindows("Drewniane okna");
    }

    @Override
    public void buildDoors() {
        house.setDoors("Solidne drewniane drzwi");
    }

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

// Reżyser (opcjonalnie)
class Director {
    public void constructStoneHouse(HouseBuilder builder) {
        builder.buildWalls();
        builder.buildRoof();
        builder.buildWindows();
        builder.buildDoors();
    }
}

// Użycie
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); // Wypisze: House{walls='Kamienne ściany', roof='Tynk z dachówki', windows='Drewniane okna', doors='Solidne drewniane drzwi'}
    }
}

Czym jest Builder w kontekście projektowania oprogramowania?