建造者模式（Builder Pattern）

建造者模式（将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式）

• 例子：一台电脑由主机、电脑显示器、键盘、鼠标四个部件组成，不同品牌电脑部件型号不同，类图如下：
  

• 建造者模式的主要角色
  产品角色（Product）：它是包含多个组成部件的复杂对象。
  抽象建造者（Builder）：包含创建产品各个子部件的抽象方法接口，通常还包含一个返回复杂产品的方法 getResult()。
  具体建造者（Concrete Builder）：实现复杂产品的各个部件的具体创建方法。
  指挥者（Director）：调用建造者对象中部件构造方法并返回产品。

• 代码实现

产品角色

/**
 * 电脑
 */
public class Computer {
    // 主机
    private String hostComputer;
    // 电脑显示器
    private String computerMonitors;
    // 键盘
    private String keyboard;
    // 鼠标
    private String mouse;
    public void setHostComputer(String hostComputer) {
        this.hostComputer = hostComputer;
    }
    public void setComputerMonitors(String computerMonitors) {
        this.computerMonitors = computerMonitors;
    }
    public void setKeyboard(String keyboard) {
        this.keyboard = keyboard;
    }
    public void setMouse(String mouse) {
        this.mouse = mouse;
    }
    public void show() {
        System.out.println("电脑=" + hostComputer + "+" + computerMonitors + "+" + keyboard + "+" + mouse);
    }
}

抽象建造者

/**
 * 建造者
 */
public abstract class Builder {
    Computer computer = new Computer();
    abstract void buildHostComputer();
    abstract void buildComputerMonitors();
    abstract void buildKeyboard();
    abstract void buildMouse();
    public Computer getResult() {
        return computer;
    }
}

具体建造者

/**
 * 华为工厂工人
 */
public class HuaweiWorker extends Builder {
    @Override
    void buildHostComputer() {
        super.computer.setHostComputer("华为主机");
    }
    @Override
    void buildComputerMonitors() {
        super.computer.setComputerMonitors("华为显示器");
    }
    @Override
    void buildKeyboard() {
        super.computer.setKeyboard("华为键盘");
    }
    @Override
    void buildMouse() {
        super.computer.setMouse("华为鼠标");
    }
}
/**
 * 苹果工厂工人
 */
public class AppleWorker extends Builder {
    @Override
    void buildHostComputer() {
        super.computer.setHostComputer("苹果主机");
    }
    @Override
    void buildComputerMonitors() {
        super.computer.setComputerMonitors("苹果显示器");
    }
    @Override
    void buildKeyboard() {
        super.computer.setKeyboard("苹果键盘");
    }
    @Override
    void buildMouse() {
        super.computer.setMouse("苹果鼠标");
    }
}

指挥者

/**
 * 指挥者
 */
public class Director {
    private Builder builder;
    public Director(Builder builder) {
        this.builder = builder;
    }
    public Computer construct() {
        builder.buildHostComputer();
        builder.buildComputerMonitors();
        builder.buildKeyboard();
        builder.buildMouse();
        return builder.getResult();
    }
}

测试

public class Test {
    public static void main(String[] args) {
        Director huaweiDirector = new Director(new HuaweiWorker());
        Computer huaweiComputer = huaweiDirector.construct();
        huaweiComputer.show();
        Director appleDirector = new Director(new AppleWorker());
        Computer appleComputer = appleDirector.construct();
        appleComputer.show();
    }
}
// 运行结果
电脑=华为主机+华为显示器+华为键盘+华为鼠标
电脑=苹果主机+苹果显示器+苹果键盘+苹果鼠标

• 使用场景
  1、相同的方法，不同的执行顺序，产生不同的结果。
  2、多个部件或零件，都可以装配到一个对象中，但是产生的结果又不相同。
  3、产品类非常复杂，或者产品类中不同的调用顺序产生不同的作用。
  4、初始化一个对象特别复杂，参数多，而且很多参数都具有默认值。