Java面试题：讨论建造者模式在构建复杂对象时的优势，并给出一个实现示例

建造者模式（Builder Pattern）是一种创建型设计模式，它允许用户通过分步构建一个复杂对象。建造者模式将对象的构建过程与表示过程分离，使得同样的构建过程可以创建不同的表示。其主要优势包括：

1. 解耦构建过程和表示：建造者模式将对象的构建过程独立出来，使得构建过程可以灵活变化，而不影响对象的最终表示。
2. 逐步构建复杂对象：允许通过逐步构建来创建复杂对象，使得构建过程更加清晰和易于维护。
3. 更好的代码可读性：建造者模式通过链式调用的方式，可以使代码更加易读，尤其是创建具有多个参数的对象时。
4. 可变的对象表示：同样的构建过程可以创建不同的表示，适用于需要多种不同表示的对象构建场景。

示例：Java 中的建造者模式

步骤1：定义产品类

public class House {
    private String foundation;
    private String structure;
    private String roof;
    private String interior;

    // Getters and setters
    public String getFoundation() {
        return foundation;
    }

    public void setFoundation(String foundation) {
        this.foundation = foundation;
    }

    public String getStructure() {
        return structure;
    }

    public void setStructure(String structure) {
        this.structure = structure;
    }

    public String getRoof() {
        return roof;
    }

    public void setRoof(String roof) {
        this.roof = roof;
    }

    public String getInterior() {
        return interior;
    }

    public void setInterior(String interior) {
        this.interior = interior;
    }

    @Override
    public String toString() {
        return "House{" +
                "foundation='" + foundation + '\'' +
                ", structure='" + structure + '\'' +
                ", roof='" + roof + '\'' +
                ", interior='" + interior + '\'' +
                '}';
    }
}

步骤2：定义建造者接口

public interface HouseBuilder {
    void buildFoundation();
    void buildStructure();
    void buildRoof();
    void buildInterior();
    House getHouse();
}

步骤3：实现具体建造者

public class ConcreteHouseBuilder implements HouseBuilder {
    private House house;

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

    @Override
    public void buildFoundation() {
        house.setFoundation("Concrete, brick, and stone");
        System.out.println("Foundation complete.");
    }

    @Override
    public void buildStructure() {
        house.setStructure("Wood and bricks");
        System.out.println("Structure complete.");
    }

    @Override
    public void buildRoof() {
        house.setRoof("Tiles");
        System.out.println("Roof complete.");
    }

    @Override
    public void buildInterior() {
        house.setInterior("Painting, electrical, and plumbing");
        System.out.println("Interior complete.");
    }

    @Override
    public House getHouse() {
        return this.house;
    }
}

步骤4：定义指导者

public class ConstructionEngineer {
    private HouseBuilder houseBuilder;

    public ConstructionEngineer(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    public House constructHouse() {
        this.houseBuilder.buildFoundation();
        this.houseBuilder.buildStructure();
        this.houseBuilder.buildRoof();
        this.houseBuilder.buildInterior();
        return this.houseBuilder.getHouse();
    }
}

步骤5：使用建造者模式创建对象

public class BuilderPatternDemo {
    public static void main(String[] args) {
        HouseBuilder concreteHouseBuilder = new ConcreteHouseBuilder();
        ConstructionEngineer engineer = new ConstructionEngineer(concreteHouseBuilder);

        House house = engineer.constructHouse();
        System.out.println("House constructed: " + house);
    }
}

结果输出

Foundation complete.
Structure complete.
Roof complete.
Interior complete.
House constructed: House{foundation='Concrete, brick, and stone', structure='Wood and bricks', roof='Tiles', interior='Painting, electrical, and plumbing'}

在这个示例中，通过HouseBuilder接口和ConcreteHouseBuilder具体实现类，将House对象的构建过程进行了分步处理。ConstructionEngineer作为指导者（Director），负责调用建造者的各个步骤，最终创建出完整的House对象。建造者模式的优势在于它将复杂对象的构建过程与对象的表示分离，使得代码更加清晰、易于维护和扩展。