¿Qué es el patrón de diseño 'Constructor' (Builder)…

El patrón "Builder" (Constructor) es un patrón de diseño creacional que permite crear objetos complejos paso a paso, proporcionando diferentes opciones de configuración.

Propósito: Separar el proceso de construcción de un objeto de su representación. Permite obtener diferentes representaciones del mismo proceso de construcción.
Ventajas:
- Permite construir un objeto paso a paso, ocultando los detalles de la construcción.
- Facilita la creación de objetos con un gran número de parámetros opcionales (a diferencia de los constructores con múltiples argumentos o el anti-patrón Telescoping Constructors).
- Se puede usar el mismo código de construcción para crear diferentes representaciones del objeto.
Participantes principales:
1. Builder (Constructor): Interfaz o clase abstracta que define los pasos para construir las partes del objeto.
2. ConcreteBuilder (Constructor Concreto): Implementación de la interfaz Builder, que crea partes específicas del objeto y proporciona un método para obtener el resultado final.
3. Director: Define la secuencia de pasos para crear el objeto, usando un objeto Builder. El Director es opcional y el cliente puede trabajar directamente con el Builder.
4. Product (Producto): El objeto que se construye.

Ejemplo de estructura (Java):

// Producto
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 + "]";
    }
}

// Interfaz Builder
interface CarBuilder {
    void buildEngine();
    void buildWheels();
    void buildColor();
    Car getResult();
}

// Constructor Concreto
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 (Opcional)
class CarDirector {
    private CarBuilder builder;

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

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

// Uso del cliente
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("Built car: " + sportsCar);

        // Uso directo sin Director
        CarBuilder anotherSportsCarBuilder = new SportsCarBuilder();
        anotherSportsCarBuilder.buildEngine();
        anotherSportsCarBuilder.buildColor(); // Construir sin ruedas
        Car partialCar = anotherSportsCarBuilder.getResult();
        System.out.println("Built partial car: " + partialCar);
    }
}

¿Qué es el patrón de diseño 'Constructor' (Builder)?