建造者模式

建造者模式

1. 定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
2. 优点：封装性（不需要关心每一个具体的模型内部是如何实现的）；建造者独立，容易扩展；便于控制细节风险。
3. 使用场景：相同的方法，不同的执行顺序，产生不同的事件结果时；多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时。

建造汽车模型为例

1.Product产品类

/汽车模板类
public abstract class CarModel {
    // 这个参数是各个基本方法执行的顺序
    private ArrayList<String> sequence = new ArrayList<String>();

    // 模型是启动开始跑了
    protected abstract void start();

    // 能发动，还要能停下来，那才是真本事
    protected abstract void stop();

    // 喇叭会出声音，是滴滴叫，还是哔哔叫
    protected abstract void alarm();

    // 引擎会轰隆隆地响，不响那是假的
    protected abstract void engineBoom();

    // 那模型应该会跑吧，别管是人推的，还是电力驱动，总之要会跑
    final public void run() {
        // 循环一边，谁在前，就先执行谁
        for (int i = 0; i < this.sequence.size(); i++) {
            String actionName = this.sequence.get(i);
            if (actionName.equalsIgnoreCase("start")) {
                this.start(); // 启动汽车
            } else if (actionName.equalsIgnoreCase("stop")) {
                this.stop(); // 停止汽车
            } else if (actionName.equalsIgnoreCase("alarm")) {
                this.alarm(); // 喇叭开始叫了
            } else if (actionName.equalsIgnoreCase("engine boom")) {
                this.engineBoom(); // 引擎开始轰鸣
            }
        }
    }

    // 把传递过来的值传递到类内
    final public void setSequence(ArrayList sequence) {
        this.sequence = sequence;
    }
}

---

//奔驰类
public class BenzModel extends CarModel {
    protected void alarm() {
        System.out.println("奔驰车的喇叭声音是这个样子的...");
    }

    protected void engineBoom() {
        System.out.println("奔驰车的引擎是这个声音的...");
    }

    protected void start() {
        System.out.println("奔驰车跑起来是这个样子的...");
    }

    protected void stop() {
        System.out.println("奔驰车应该这样停车...");
    }
}

---

//宝马类
public class BMWModel extends CarModel {
    protected void alarm() {
        System.out.println("宝马车的喇叭声音是这个样子的...");
    }

    protected void engineBoom() {
        System.out.println("宝马车的引擎是这个声音的...");
    }

    protected void start() {
        System.out.println("宝马车跑起来是这个样子的...");
    }

    protected void stop() {
        System.out.println("宝马车应该这样停车...");
    }
}

2.Builder抽象建造者

public abstract class CarBuilder {
    //建造一个模型，你要给我一个顺序要求，就是组装顺序
    public abstract void setSequence(ArrayList<String> sequence);
    //设置完毕顺序后，就可以直接拿到这个车辆模型
    public abstract CarModel getCarModel();
}

3.ConcreteBuilder具体建造者

public class BenzBuilder extends CarBuilder {

private BenzModel benz = new BenzModel();

public CarModel getCarModel() {
    return this.benz;
  }

public void setSequence(ArrayList<String> sequence) {
    this.benz.setSequence(sequence);
  }

}

---

public class BMWBuilder extends CarBuilder {
    private BMWModel bmw = new BMWModel();

    public CarModel getCarModel() {
        return this.bmw;
    }

    public void setSequence(ArrayList<String> sequence) {
        this.bmw.setSequence(sequence);
    }
}

4.Director导演类

public class Director {
private ArrayList<String> sequence = new ArrayList();
private BenzBuilder benzBuilder = new BenzBuilder();
private BMWBuilder bmwBuilder = new BMWBuilder();

/*
 * A类型的奔驰车模型，先start，然后stop，其他什么引擎、喇叭一概没有
 */
public BenzModel getABenzModel() {
    // 清理场景，这里是一些初级程序员不注意的地方
    this.sequence.clear();
    // ABenzModel的执行顺序
    this.sequence.add("start");
    this.sequence.add("stop");
    // 按照顺序返回一个奔驰车
    this.benzBuilder.setSequence(this.sequence);
    return (BenzModel) this.benzBuilder.getCarModel();
}

/*
 * B型号的奔驰车模型，是先发动引擎，然后启动，然后停止，没有喇叭
 */
public BenzModel getBBenzModel() {
    this.sequence.clear();
    this.sequence.add("engine boom");
    this.sequence.add("start");
    this.sequence.add("stop");
    this.benzBuilder.setSequence(this.sequence);
    return (BenzModel) this.benzBuilder.getCarModel();
}

/*
 * C型号的宝马车是先按下喇叭（炫耀嘛），然后启动，然后停止
 */
public BMWModel getCBMWModel() {
    this.sequence.clear();
    this.sequence.add("alarm");
    this.sequence.add("start");
    this.sequence.add("stop");
    this.bmwBuilder.setSequence(this.sequence);
    return (BMWModel) this.bmwBuilder.getCarModel();
}

/*
 * D类型的宝马车只有一个功能，就是跑，启动起来就跑，永远不停止
 */
public BMWModel getDBMWModel() {
    this.sequence.clear();
    this.sequence.add("start");
    this.bmwBuilder.setSequence(this.sequence);
    return (BMWModel) this.benzBuilder.getCarModel();
}
/*
 * 这里还可以有很多方法，你可以先停止，然后再启动，或者一直停着不动，静态的嘛 导演类嘛，按照什么顺序是导演说了算
 */
}

5.场景测试类

public class Client {

    public static void main(String[] args) {

        Director director = new Director();
        // 3辆A类型的奔驰车
        for (int i = 0; i < 3; i++) {
            director.getABenzModel().run();
        }
        // 2辆B类型的奔驰车
        for (int i = 0; i < 2; i++) {
            director.getBBenzModel().run();
        }
        // 1辆C类型的宝马车
        for (int i = 0; i < 1; i++) {
            director.getCBMWModel().run();
        }

    }

}

注：《设计模式之禅》笔记