建造者模式

1，建造者模式是一个创建对象的模式
2，与工厂模式很像，建造者模式主要思考的方向是零件的顺序不同创建对象不同，工厂方法不会关注创建零件时的顺序
3，建造者模式经常和模板方法一起使用

看一下类图

建造者模式类图

1，需要有产品的抽象类定义产品生成规则
2，产品实现类实现产品具体行为（这里就使用了模板方法模式）
3，建造者抽象类构造产品规则
4，建造者实现类构造具体的产品
5，执行类隔离高层组件按顺序构造各种产品

下面我们使用建造者模式来构造汽车
需求：我们需要建造汽车类，可以构造不同，汽车有如下功能（启动，停止，喇叭执行声音，引擎执行声音）。汽车运行时会执行以上不同方法，并且方法顺序不固定

我们来一步步实现这个需求
1，构造车的抽象类
使用一个集合存储基本执行方法的顺序

public abstract class CarModel {
    //这个参数是各个基本方法执行的顺序
    private ArrayList<String> sequence = new ArrayList<>();
    //模型开始跑了
    abstract void start();
    //停止
    abstract void stop();
    //喇叭声音
    abstract void alarm();
    //引擎隆隆响
    abstract void engineBoom();

    public final void run(){
        //循环，谁在前，谁先执行
        for (String s:sequence){
            if (s.equals("start")){
                this.start();
            } else if (s.equals("stop")){
                this.stop();
            }if (s.equals("alarm")){
                this.alarm();
            }if (s.equals("engineBoom")){
                this.engineBoom();
            }
        }
    }

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

2，汽车的具体实现类，比如我们要成产两种车，奔驰和宝马

public class BMWModel extends CarModel{
    @Override
    void start() {
        System.out.println("宝马start");
    }

    @Override
    void stop() {
        System.out.println("宝马stop");
    }

    @Override
    void alarm() {
        System.out.println("宝马alarm");
    }

    @Override
    void engineBoom() {
        System.out.println("宝马engineBoom");
    }
}


public class BenzModel extends CarModel{
    @Override
    void start() {
        System.out.println("奔驰start");
    }

    @Override
    void stop() {
        System.out.println("奔驰stop");
    }

    @Override
    void alarm() {
        System.out.println("奔驰alarm");
    }

    @Override
    void engineBoom() {
        System.out.println("奔驰engineBoom");
    }
}

3，建造者的抽象类，建造者的抽象规则

public abstract class CarBuilder {
    //确定运行的顺序
    public abstract void setSequence(ArrayList<String> sequence);
    public abstract CarModel getCarModel();
}

4，建造者实现类，有几个产品就实现几个建造者类，我们这里有两个产品，所以有两个

public class BMWBuilder extends CarBuilder{

    private BMWModel bmwModel = new BMWModel();
    @Override
    public void setSequence(ArrayList<String> sequence) {
        bmwModel.setSequence(sequence);
    }

    @Override
    public CarModel getCarModel() {
        return bmwModel;
    }
}

public class BenzBuilder extends CarBuilder{

    private BenzModel benz = new BenzModel();

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

    @Override
    public CarModel getCarModel() {
        return benz;
    }
}

5，执行类，用于隔离上层组件和组装对象的管理类
执行创建产品前都需要清空基本方法执行顺序

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

    public BenzModel getABenzBuilder() {
        this.sequence.clear();
        this.sequence.add("start");
        this.sequence.add("stop");
        this.benzBuilder.setSequence(sequence);
        return (BenzModel) benzBuilder.getCarModel();
    }

    public BenzModel getBBenzBuilder() {
        this.sequence.clear();
        this.sequence.add("start");
        this.sequence.add("alarm");
        this.benzBuilder.setSequence(sequence);
        return (BenzModel) benzBuilder.getCarModel();
    }

    public BMWModel getABMWBuilder() {
        this.sequence.clear();
        this.sequence.add("engineBoom");
        this.sequence.add("stop");
        this.bmwBuilder.setSequence(sequence);
        return (BMWModel) bmwBuilder.getCarModel();
    }

    public BMWModel getBBMWBuilder() {
        this.sequence.clear();
        this.sequence.add("alarm");
        this.sequence.add("stop");
        this.bmwBuilder.setSequence(sequence);
        return (BMWModel) bmwBuilder.getCarModel();
    }
}

6，调用

public class Main {
    public static void main(String[] args){
        BenzModel benzModel = new Director().getBBenzBuilder();
        benzModel.run();
    }
}

我们看到调用非常简单，并且如果我们需要扩展非常方便，比如加一个保时捷，只需要在增加一个保时捷的实现类，和一个保时捷的建造者，在管理类中增加生产保时捷的对象方法就可以了