¿Qué es un constructor (Builder) en el contexto del…

Este es un patrón de diseño creacional que separa la construcción de un objeto complejo de su representación, permitiendo crear diferentes representaciones del objeto utilizando el mismo proceso de construcción.

Principio de funcionamiento:

Producto (Product): Objeto complejo que se desea construir.
Constructor (Builder): Interfaz abstracta para crear partes del producto.
Constructor Concreto (Concrete Builder): Implementación de la interfaz "Constructor" que crea partes específicas del producto y las ensambla en un producto final.
Director (opcional): Define la secuencia de pasos para la construcción y utiliza el Constructor para crear el producto.

Ventajas:

Permite construir objetos complejos paso a paso.
Separa la lógica de construcción del objeto del propio objeto.
Permite crear diferentes representaciones del objeto con el mismo proceso.
Facilita la extensión mediante la adición de nuevos Constructores Concretos.

Desventajas:

Incrementa la cantidad de clases debido a la necesidad de crear diferentes Constructores Concretos.
Puede complicar el código para objetos simples.

Ejemplo de uso (Java):

Imaginemos la creación de un objeto complejo "Casa":

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

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

// Constructor Concreto
class StoneHouseBuilder implements HouseBuilder {
    private House house;

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

    @Override
    public void buildWalls() {
        house.setWalls("Stone Walls");
    }

    @Override
    public void buildRoof() {
        house.setRoof("Tile Roof");
    }

    @Override
    public void buildWindows() {
        house.setWindows("Wooden Windows");
    }

    @Override
    public void buildDoors() {
        house.setDoors("Solid Wooden Doors");
    }

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

// Director (opcional)
class Director {
    public void constructStoneHouse(HouseBuilder builder) {
        builder.buildWalls();
        builder.buildRoof();
        builder.buildWindows();
        builder.buildDoors();
    }
}

// Uso
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); // Output: House{walls='Stone Walls', roof='Tile Roof', windows='Wooden Windows', doors='Solid Wooden Doors'}
    }
}

¿Qué es un constructor (Builder) en el contexto del diseño de software?