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

El patrón de diseño "Builder" (Constructor) es un patrón creacional que proporciona una forma de crear un objeto complejo paso a paso. Separa el proceso de construcción de un objeto complejo de su representación, lo que permite usar el mismo proceso de construcción para crear diferentes representaciones.

Componentes clave del patrón:

Builder: Interfaz abstracta o concreta (o clase) que define un conjunto de métodos para construir paso a paso las partes del producto.
ConcreteBuilder: Implementación concreta de Builder que crea una representación específica del producto. Conoce todos los detalles de la construcción.
Director: Clase opcional, pero a menudo utilizada. Define el orden en que se llaman los pasos de construcción para crear una configuración específica del producto.
Product: Objeto complejo que se construye. Está compuesto por muchas partes.

Ventajas:

Permite crear objetos complejos paso a paso, evitando constructores "telescópicos" (constructores con muchos parámetros).
Encapsula la lógica de creación del objeto complejo.
Facilita el cambio en la representación interna del producto.
Permite usar el mismo proceso de construcción para crear diferentes variantes del producto.

Aplicabilidad:

Cuando el proceso de creación de un objeto implica muchos pasos y estos pasos deben realizarse en un orden específico.
Cuando se necesita tener diferentes representaciones del mismo objeto.
Cuando el constructor del objeto tiene muchos parámetros opcionales.

Ejemplo:

// Producto
class Pizza {
    private String dough = "";
    private String sauce = "";
    private List<String> toppings = new ArrayList<>();

    public void setDough(String dough) {
        this.dough = dough;
    }

    public void setSauce(String sauce) {
        this.sauce = sauce;
    }

    public void addTopping(String topping) {
        this.toppings.add(topping);
    }

    @Override
    public String toString() {
        return "Pizza con masa: " + dough + ", salsa: " + sauce + ", ingredientes: " + toppings;
    }
}

// Interfaz del Constructor
interface PizzaBuilder {
    void buildDough();
    void buildSauce();
    void buildToppings();
    Pizza getPizza();
}

// Constructor Concreto
class MargheritaPizzaBuilder implements PizzaBuilder {
    private Pizza pizza = new Pizza();

    @Override
    public void buildDough() {
        pizza.setDough("masa fina");
    }

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

    @Override
    public void buildToppings() {
        pizza.addTopping("mozzarella");
        pizza.addTopping("albahaca");
    }

    @Override
    public Pizza getPizza() {
        return this.pizza;
    }
}

// Director (opcional)
class Cook {
    private PizzaBuilder pizzaBuilder;

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

    public Pizza getPizza() {
        return pizzaBuilder.getPizza();
    }

    public void constructPizza() {
        pizzaBuilder.buildDough();
        pizzaBuilder.buildSauce();
        pizzaBuilder.buildToppings();
    }
}

// Uso
public class BuilderExample {
    public static void main(String[] args) {
        Cook cook = new Cook();
        PizzaBuilder margheritaBuilder = new MargheritaPizzaBuilder();

        cook.setPizzaBuilder(margheritaBuilder);
        cook.constructPizza();

        Pizza margherita = cook.getPizza();
        System.out.println(margherita);
    }
}

En el contexto de la automatización de pruebas, "Builder" se usa a menudo para crear datos de prueba u objetos de prueba complejos (por ejemplo, un objeto usuario con múltiples atributos, un objeto pedido con varias posiciones), cuando se requiere configurar de manera flexible diferentes variantes de estos datos para distintos escenarios de prueba.

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