设计模式-建造者模式

现在有一个大合同，把奔驰、宝马的车辆模型都制作，有额外添加一个需求：汽车的启动、停止、喇叭声音、引擎声音都有客户自己的控制，他想什么顺序就什么顺序。
首先我们得思考了，奔驰宝马都是一个产品，他们有共有的属性。由我生产N多个奔驰和宝马车辆模型，这些车辆模型都有run方法，但具体到每一个模型的run方法可能中间的执行任务的顺序是不同的，客户需要啥顺序，我就给啥顺序，最终用户买走的只能是既定的模型。我们继续，我们先把我们最基本的Product在类中表明出来：

我们定义一个CarModel的抽象类，其中run和setSequence是由抽象类实现的，其他都是子类自己实现，那这个是否可以解决这个问题呢？应该可以，我们把代码实现出来，先看CarModel.java程序:

package com.example.xpeng.myapplication;

import java.util.ArrayList;

/**
 * Created by xpeng on 2018/5/31.
 * 定义一个车辆模型的抽象类，所有的车辆模型都继承这个类
 */

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<String> sequence){
        this.sequence = sequence;
    }

}

其中setSequence方法允许客户自己设置一个顺序，是要先跑起来在有引擎声音还是现有引擎声音再跑起来，还是说那个喇叭就不要响，对于一个具体的模型永远都固定的，那这个事由客户告诉我们，有1W件是这样的，1W件是那样的顺序，目前的设计能满足这个要求
run方法使用了一个数组的遍历，确定哪个是先执行，不多说了，我们继续看两个实现类，先看BenzModel.java程序：

package com.example.xpeng.myapplication;

import android.util.Log;

/**
 * Created by xpeng on 2018/5/31.
 */

public class BenModel extends CarModel {

    @Override
    protected void alarm() {
        Log.e("xyz","奔驰车的喇叭声音是这个样子的...");
    }

    @Override
    protected void start() {
        Log.e("xyz","奔驰车跑起来这个样子的...");
    }

    @Override
    protected void stop() {
        Log.e("xyz","奔驰车应该这样停车的...");
    }

    @Override
    protected void engineBoom() {
        Log.e("xyz","奔驰车的引擎是这个声音的...");
    }
}

没啥特别的，再看BMWModel.java程序:

package com.example.xpeng.myapplication;

import android.util.Log;

/**
 * Created by xpeng on 2018/5/31.
 */

public class BMWModel extends CarModel {

    @Override
    protected void alarm() {
        Log.e("xyz","宝马车的喇叭声音是这个样子的...");
    }

    @Override
    protected void start() {
        Log.e("xyz","宝马车跑起来这个样子的...");
    }

    @Override
    protected void stop() {
        Log.e("xyz","宝马车应该这样停车的...");
    }

    @Override
    protected void engineBoom() {
        Log.e("xyz","宝马车的引擎是这个声音的...");
    }
}

两个实现类都完成，我们再来看客户的要求，我先要1W个奔驰的模型，这个模型的要求是跑的时候，现发动引擎，然后再挂挡启动，然后停下来,不需要喇叭，那怎么实现呢:

        BenzModel benz = new BenzModel();
       ArrayList<String> sequence = new ArrayList<String>();
        sequence.add("engine boom");
        sequence.add("start");
        sequence.add("stop");
        benz.setSequence(sequence);
        benz.run();

看，满足了客户的需求了，满足完了，还要下一个需求啊，然后第2件宝马模型，只要启动和停止，其他什么都不要，第三件模型，现喇叭，第四件模型。。。知道逼疯为止，那怎么办？
我们修改程序，满足这种变态需求，好，先看修改的类图：

增加了一个CarBuilder的抽象类，以及两个实现类，其目的是你要什么排列顺序的车，我就给你什么顺序的车，那我们先看CarBuilder.java抽象类的程序：

package com.example.xpeng.myapplication;

import java.util.ArrayList;

/**
 * Created by xpeng on 2018/5/31.
 * 要什么顺序的车，你说，我给建造出来
 */

public abstract class CarBuilder {

    //建造一个模型，你要给我一个顺序，就是组装顺序
    public abstract void setSequence(ArrayList<String> sequence);

    //设置完毕顺序后，就可以直接拿到这个车辆模型
    public abstract CarModel getCarModel();

}

这个抽象类比较简单，程序上也有注释，不多说，我们看两个实现类，先看BenzBuilder.java的程序代码：

package com.example.xpeng.myapplication;

import java.util.ArrayList;

/**
 * Created by xpeng on 2018/5/31.
 * 各种设置都给了，我们按照一定的顺序制造一个奔驰车
 */

public class BenzBuilder extends CarBuilder {
    private BenModel banz = new BenModel();

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

    @Override
    public CarModel getCarModel() {
        return this.banz;
    }
}

下面是BMWBuilder.java程序代码：

package com.example.xpeng.myapplication;

import java.util.ArrayList;

/**
 * Created by xpeng on 2018/5/31.
 * 各种设置都给了，我们按照一定的顺序制造一个奔驰车
 */

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

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

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

程序简单实用，看我们怎么调用：

        ArrayList<String> sequence = new ArrayList<String>();

        sequence.add("engine boom");
        sequence.add("start");
        sequence.add("stop");

        //要一个奔驰车
        BenzBuilder benzBuilder = new BenzBuilder();
        //把顺序给这个builder类，制造出这样一个车出来
        benzBuilder.setSequence(sequence);
        //制造出一个奔驰车
        BenModel benz = (BenModel) benzBuilder.getCarModel();
        //奔驰车跑一下看看
        benz.run();

        //按照同样的顺序，我再要一个宝马车
        BMWBuilder bmwBuilder = new BMWBuilder();
        benzBuilder.setSequence(sequence);
        BenModel bmw = (BenModel) bmwBuilder.getCarModel();
        bmw.run();

看，是不是比刚才直接访问产品类（procut）简单了很多把，那还有个这样的需求，这四个过程(start,stop,alarm,engineBoom)按照排列组合有很多种，那我们怎么满足这种需求呢？就是要有个类来安排这几个方法组合，我们这个叫导演类，先看一下类图：

增加了Director类，这个类是做了层封装，类中的方法说明如下：
A型号的奔驰车辆模型是只有启动（start）、停止(stop)方法，其他的引擎声音、喇叭都没有；
B型号车的奔驰是现发动引擎。。
C型号的宝马车是先叫一下喇叭（alarm）…
D型号宝马车是先一个启动(start)。。。
后面的E型号、F型号随意组合

我们来看一下代码实现，Director.java代码如下:

package com.example.xpeng.myapplication;

import java.util.ArrayList;

/**
 * Created by xpeng on 2018/5/31.
 * 导演安排顺序，生产车辆模型
 */

public class Director {
    private ArrayList<String> sequence = new ArrayList<>();

    private BenzBuilder benzBuilder = new BenzBuilder();

    private BMWBuilder bmwBuilder = new BMWBuilder();

    /**
     * A类型的奔驰车模型，先start，然后stop，其他什么引擎了，喇叭一概没有
     */
    public BenModel getABenzModel(){
        //清理场景
        this.sequence.clear();
        //这只ABenzModel的执行顺序
        this.sequence.add("start");
        this.sequence.add("stop");
        //按照顺序返回一个奔驰车
        this.benzBuilder.setSequence(this.sequence);
        return (BenModel) this.benzBuilder.getCarModel();
    }

    /**
     * B类型的奔驰车模型
     */
    public BenModel getBBenzModel(){
        //清理场景
        this.sequence.clear();
        //这只ABenzModel的执行顺序
        this.sequence.add("alarm");
        this.sequence.add("start");
        this.sequence.add("stop");
        //按照顺序返回一个奔驰车
        this.benzBuilder.setSequence(this.sequence);
        return (BenModel) this.benzBuilder.getCarModel();
    }


    /**
     * C类型的宝马车模型
     */
    public BMWModel getCBWMModel(){
        //清理场景
        this.sequence.clear();
        //这只ABenzModel的执行顺序
        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 getDBWMModel(){
        //清理场景
        this.sequence.clear();
        //这只ABenzModel的执行顺序
        this.sequence.add("start");
        //按照顺序返回一个奔驰车
        this.bmwBuilder.setSequence(this.sequence);
        return (BMWModel) this.bmwBuilder.getCarModel();
    }

}

大家看到程序中有很多this调用，如果你要调用类中的成员变量或方法，需要在前面加上this关键字，，加上this关键字，我就是要调用本类中成员变量或方法，而不是本方法中的一个变量，还有super方法也是一样，是调用父类的成员变量或者方法，那就要加上这个关键字，不要省略。

最终调用方法：

   Director director = new Director();

        for (int i = 0; i <3 ; i++) {
            director.getABenzModel().run();
        }

        for (int i = 0; i <5 ; i++) {
            director.getBBenzModel().run();
        }

        for (int i = 0; i <1 ; i++) {
            director.getCBWMModel().run();
        }

整个程序编写完了，这就是建造者模式，中间有几个角色需要说明一下：
CarModel以及两个实现类BenzModel和BMWModel叫做产品类（product Class），这个产品类实现了模版方法模式，也就是有模版方法和基本方法，这个参考模版方法模式；
CarBuilder以及两个实现类BenzBuilder和BMWBuilder叫做建造者（Builder Class），在上面的那个例子中就是我，负责建造Benz和BMW车模，按照指定的顺序：
Director类叫做导演类（Director Class），负责安排已有模块的顺序，然后告诉Builder开始建造
大家看到这里是不是觉得这个建造者模式跟工厂模式非常相似，是的，是非常相似，但是记住一点你就可以游刃有余的使用了：建造者模式最主要功能是基本方法的调用顺序安排，也就是这些基本方法已经实现了；而工厂方法则重点是创建，你要什么对象我创造一个对象出来，组装顺序不是它关心的。

建造者模式demo下载地址：

建造者模式DEMO