Ce este pattern-ul de proiectare 'Builder'…

Modelul "Builder" (Constructor) este un pattern de proiectare creational care permite crearea pas cu pas a obiectelor complexe, oferind diferite opțiuni de configurare.

Scop: Să separe procesul de construcție al unui obiect de reprezentarea sa. Permite obținerea diferitelor reprezentări ale aceluiași proces de construcție.
Avantaje:
- Permite construirea pas cu pas a unui obiect, ascunzând detaliile construcției.
- Facilitează crearea de obiecte cu un număr mare de parametri opționali (spre deosebire de constructorii cu mulți argumente sau anti-modelul Telescoping Constructors).
- Același cod de construcție poate fi folosit pentru a crea diferite reprezentări ale obiectului.
Participanți principali:
1. Builder (Constructor): Interfață sau clasă abstractă care definește pașii pentru construirea părților obiectului.
2. ConcreteBuilder (Constructor Concret): Implementarea interfeței Builder, care creează părți specifice ale obiectului și oferă o metodă pentru a obține rezultatul final.
3. Director: Definește secvența de pași pentru crearea obiectului, folosind un obiect Builder. Directorul este opțional, iar clientul poate lucra direct cu Builder-ul.
4. Product (Produs): Obiectul care se construiește.

Exemplu de structură (Java):

// Produs
class Car {
    private String engine;
    private int wheels;
    private String color;

    public void setEngine(String engine) {
        this.engine = engine;
    }

    public void setWheels(int wheels) {
        this.wheels = wheels;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Car [engine=" + engine + ", wheels=" + wheels + ", color=" + color + "]";
    }
}

// Interfață Builder
interface CarBuilder {
    void buildEngine();
    void buildWheels();
    void buildColor();
    Car getResult();
}

// Builder Concret
class SportsCarBuilder implements CarBuilder {
    private Car car = new Car();

    @Override
    public void buildEngine() {
        car.setEngine("V8");
    }

    @Override
    public void buildWheels() {
        car.setWheels(4);
    }

    @Override
    public void buildColor() {
        car.setColor("Red");
    }

    @Override
    public Car getResult() {
        return car;
    }
}

// Director (Opțional)
class CarDirector {
    private CarBuilder builder;

    public CarDirector(CarBuilder builder) {
        this.builder = builder;
    }

    public void constructCar() {
        builder.buildEngine();
        builder.buildWheels();
        builder.buildColor();
    }
}

// Utilizare client
public class Client {
    public static void main(String[] args) {
        CarBuilder sportsCarBuilder = new SportsCarBuilder();
        CarDirector director = new CarDirector(sportsCarBuilder);

        director.constructCar();
        Car sportsCar = sportsCarBuilder.getResult();
        System.out.println("Mașina construită: " + sportsCar);

        // Utilizare directă fără Director
        CarBuilder anotherSportsCarBuilder = new SportsCarBuilder();
        anotherSportsCarBuilder.buildEngine();
        anotherSportsCarBuilder.buildColor(); // Construiește fără roți
        Car partialCar = anotherSportsCarBuilder.getResult();
        System.out.println("Mașină parțială construită: " + partialCar);
    }
}

Ce este pattern-ul de proiectare 'Builder' (Constructor)?