建造者模式

定义

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

使用场景

1. 相同的方法，不同的执行顺序，产生不同的事件结果时。
2. 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时。
3. 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的作用。非常适合 Builder 模式。
4. 当初始化一个对象特别复杂，如参数多，而且很多参数都具有缺省值时。

实现方式

Product 角色（抽象类）

// 计算机抽象类，即 Product 角色
public abstract class Computer {
    private String mCpu;
    private String mDisplayCard;
    private String mMemory;
    private String mHardDisk;
    private String mOS;

    protected Computer() {  }
    // 设置 CPU
    public void setCpu(String cpu) {
        this.mCpu = cpu;
    }
    // 设置 显卡
    public void setDisplayCard(String displayCard) {
        this.mDisplayCard = displayCard;
    }
    // 设置 内存
    public void setMemory(String memory) {
        this.mMemory = memory;
    }
    // 设置 硬盘
    public void setHardDisk(String hardDisk) {
        this.mHardDisk = hardDisk;
    }
    // 设置 操作系统
    public abstract void setOS();

    @Override
    public String toString() {
        return "Computer [CPU=" + mCpu + ", 显卡=" + mDisplayCard + ", 内存=" + mMemory + ", 硬盘=" + mHardDisk + ", 操作系统=" + mOS + "]";
    }
}

Product 角色（具体实现类）

public class HP extends Computer {
    protected HP() {  }
    
    @Override
    public void setOS() {
        mOS = "Windows 10 旗舰版";
    }
}

Builder 角色（抽象类）

public abstract class Builder {
    // 构建 Cpu
    public abstract void buildCpu(String cpu);
    // 构建 显卡
    public abstract void buildDisplayCard(String displayCard);
    // 构建 内存
    public abstract void buildMemory(String memory);
    // 构建 硬盘
    public abstract void buildHardDisk(String hardDisk);
    // 构建 操作系统
    public abstract void buildOS();
    // 创建（组装）Computer
    public abstract Computer create();
}

Builder 角色（具体实现类）

public class HPBuilder extends Builder {
    private Computer computer = new HP();

    @Override
    public void buildCpu(String cpu) {
        computer.setCpu(cpu);
    }

    @Override
    public void buildDisplayCard(String displayCard) {
        computer.setDisplayCard(displayCard);
    }

    @Override
    public void buildMemory(String memory) {
        computer.setMemory(memory);
    }

    @Override
    public void buildHardDisk(String hardDisk) {
        computer.setHardDisk(hardDisk);
    }

    @Override
    public void buildOS() {
        computer.setOS();
    }

    @Override
    public Computer create() {
        return computer;
    }

}

Director 角色，负责构造 Computer

public class Director {
    Builder mBuilder = null;
    public Director(Builder builder) {
        this.mBuilder = builder;
    }
    
    // 构建 Builder 对象
    public void construct(String cpu, String displayCard, String memory, String hardDisk) {
        mBuilder.buildCpu(cpu);
        mBuilder.buildDisplayCard(displayCard);
        mBuilder.buildMemory(memory);
        mBuilder.buildHardDisk(hardDisk);
        mBuilder.buildOS();
    }
}

测试

public class BuilderTest {
    public static void main(String[] args) {
        // Builder
        Builder builder = new HPBuilder();
        // Director
        Director director = new Director(builder);
        // 构建封装过程，i7\GTX1080\16G\512G SSD
        director.construct("Intel i7 8700", "微星 GeForce GTX1080 Ti", "Kingston 16G", "Western Digital 500GB SSD");
        // 构建 & 输出信息
        System.out.println("Computer Info:" + builder.create().toString());
    }
}

注意

实际应用场景中，经常会省略掉 Director 这个角色，直接通过 Builder 来进行对象的组装，并通过链式进行调用。参见 AlertDialog.Builder 以及 Universal-Image-Loader 的初始化配置代码。