动机

在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常有各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
如何应对这种变化？如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构建算法”不随着需求改变而改变？

模式定义

将一个复杂对象的构建与表示相分离，使得同样的构建过程（稳定）可以创建不同的表示（变化）。

类图

总结

核心，构建的过程和对象本身相分离，由专门的构建器类聚合对象接口，使用组合的思想隔离变化。

Builder模式主要用于“分步骤构建一个复杂的对象”。在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。
变化点在哪里，封装哪里—Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”（就是Director类中的构造流程需要稳定不能变动）的需求变动。

实例

场景
建造房子，把房子和房子构建分离，形成不同种类的房子使用不同的建造类，通过一个稳定的Director类把不同种类房子的建造通过稳定的算法构造出来。

House类表示房间状态，可以是抽象类，不同种类的房子子类化它。

public class House {
    private String foundation;

    private String wall;

    private String roof;

    private String windows;

    public String getFoundation() {
        return foundation;
    }

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

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoof() {
        return roof;
    }

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

    public String getWindows() {
        return windows;
    }

    public void setWindows(String windows) {
        this.windows = windows;
    }

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

房屋构建与房子House的表示分离出来，抽取一个公共的接口，不同的子类可以实例化它。

public interface HouseBuilder {

    public abstract void foundation();

    public abstract void wall();

    public abstract void roof();

    public abstract void windows();

    public House getHouse();
}
public class StoneHouseBuilder implements HouseBuilder {
    private House house = new House();

    @Override
    public void foundation() {
        house.setFoundation("Stone house foundation");
    }

    @Override
    public void wall() {
        house.setWall("Stone house wall");
    }

    @Override
    public void roof() {
        house.setRoof("Stone house roof");
    }

    @Override
    public void windows() {
        house.setWindows("Stone house windows");
    }

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

导演类，相当于设计师，比较稳定，使用不同的构建类就可以通过稳定建造步骤构建出不同的房子。

public class HouseDirector {
    private HouseBuilder houseBuilder;

    public HouseDirector(HouseBuilder builder) {
        this.houseBuilder = builder;
    }

    public House construct() {
        houseBuilder.foundation();
        houseBuilder.wall();
        houseBuilder.roof();
        houseBuilder.windows();
        return houseBuilder.getHouse();
    }
}

客户只需要通过导演类，就可以生成不同的房子了

public class Client {
    public static void main(String[] args) {
        HouseDirector director = new HouseDirector(new StoneHouseBuilder());
        House house = director.construct();
        System.out.println(house.toString());
    }
}