建造者模式

一，建造者模式

1.什么是建造者模式

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

2.建造者模式几大角色

抽象模型和具体实现模型

抽象模型就是你要建造的对象的抽象形式，比如，我现在要建造一辆车，但是车有很多种型号，那么，这些不同型号的车就是具体实现模型，车就是抽象模型

/**
 * @Description:    抽象模型
 * @Author:         Kevin
 * @CreateDate:     2019/6/17 0:44
 * @UpdateUser:     Kevin
 * @UpdateDate:     2019/6/17 0:44
 * @UpdateRemark:   修改内容
 * @Version: 1.0
 */
public abstract class AbstractModel {

    //执行顺序
    private ArrayList<String> sequence = new ArrayList<String>();

    protected abstract void start();

    protected abstract void alarm();

    protected abstract void engineBoom();

    protected abstract void stop();

    public void run(){

        //根据执行顺序执行方法，组合成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("engineBoom")){
                //如果是engine boom关键
                this.engineBoom();
                //引擎开始轰鸣
            }
        }
    }

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

具体实现模型：

/**
 * @Description:    模型具体实现 --- A模型
 * @Author:         Kevin
 * @CreateDate:     2019/6/17 0:47
 * @UpdateUser:     Kevin
 * @UpdateDate:     2019/6/17 0:47
 * @UpdateRemark:   修改内容
 * @Version: 1.0
 */
public class ModelA extends AbstractModel{

    @Override
    protected void start() {
        System.out.println("---------> A 启动");
    }

    @Override
    protected void alarm() {
        System.out.println("---------> A 鸣笛");
    }

    @Override
    protected void engineBoom() {
        System.out.println("---------> A 引擎声");
    }

    @Override
    protected void stop() {
        System.out.println("---------> A 停止");
    }
}

/**
 * @Description:    模型具体实现 --- B模型
 * @Author:         Kevin
 * @CreateDate:     2019/6/17 0:47
 * @UpdateUser:     Kevin
 * @UpdateDate:     2019/6/17 0:47
 * @UpdateRemark:   修改内容
 * @Version: 1.0
 */
public class ModelB extends AbstractModel{

    @Override
    protected void start() {
        System.out.println("---------> B 启动");
    }

    @Override
    protected void alarm() {
        System.out.println("---------> B 鸣笛");
    }

    @Override
    protected void engineBoom() {
        System.out.println("---------> B 引擎声响起");
    }

    @Override
    protected void stop() {
        System.out.println("---------> B 停止");
    }
}

抽象和具体建造者

抽象建造者：定义建造这辆车的抽象方法

/**
 * @Description:    抽象模型建造者
 * @Author:         Kevin
 * @CreateDate:     2019/6/17 0:58
 * @UpdateUser:     Kevin
 * @UpdateDate:     2019/6/17 0:58
 * @UpdateRemark:   修改内容
 * @Version: 1.0
 */
public abstract class AbstractModelBuilder {

    public abstract AbstractModel getModel();

    public abstract void setList(ArrayList<String> list);
}

具体建造者，具体建造某一型号的车的建造者

/**
 * @Description:    模型A建造者
 * @Author:         Kevin
 * @CreateDate:     2019/6/17 1:05
 * @UpdateUser:     Kevin
 * @UpdateDate:     2019/6/17 1:05
 * @UpdateRemark:   修改内容
 * @Version: 1.0
 */
public class ModelABuilder extends AbstractModelBuilder {

    private ModelA modelA = new ModelA();

    @Override
    public AbstractModel getModel() {
        return modelA;
    }

    @Override
    public void setList(ArrayList<String> list) {
        modelA.setSequence(list);
    }
}

/**
 * @Description:    模型B建造者
 * @Author:         Kevin
 * @CreateDate:     2019/6/17 1:05
 * @UpdateUser:     Kevin
 * @UpdateDate:     2019/6/17 1:05
 * @UpdateRemark:   修改内容
 * @Version: 1.0
 */
public class ModelBBuilder extends AbstractModelBuilder {

    private ModelB modelB = new ModelB();

    @Override
    public AbstractModel getModel() {
        return modelB;
    }

    @Override
    public void setList(ArrayList<String> list) {
        modelB.setSequence(list);
    }
}

导演

导演类起到封装的作用，避免高层模块深入到建造者内部的实现类。在建造者模式比较庞大时，导演类可以有多个

/**
 * @Description:    导演类
 * @Author:         Kevin
 * @CreateDate:     2019/6/17 1:07
 * @UpdateUser:     Kevin
 * @UpdateDate:     2019/6/17 1:07
 * @UpdateRemark:   修改内容
 * @Version: 1.0
 */
public class Director {

    private ModelABuilder modelABuilder = new ModelABuilder();
    private ModelBBuilder modelBBuilder = new ModelBBuilder();
    private ArrayList<String> list = new ArrayList<>();

    public ModelA getModelA1(){
        //clear的动作，以防止数据混乱
        list.clear();
        list.add("start");
        list.add("alarm");
        list.add("engineBoom");
        list.add("stop");
        modelABuilder.setList(list);
        return (ModelA) modelABuilder.getModel();
    }

    public ModelA getModelA2(){
        list.clear();
        list.add("start");
        list.add("engineBoom");
        list.add("alarm");
        list.add("stop");
        modelABuilder.setList(list);
        return (ModelA) modelABuilder.getModel();
    }

    public ModelA getModelA3(){
        list.clear();
        list.add("alarm");
        list.add("start");
        list.add("engineBoom");
        list.add("stop");
        modelABuilder.setList(list);
        return (ModelA) modelABuilder.getModel();
    }

    //同理还可以封装更多......
}

3.建造者模式应用场景

1. 何时使用

一个基本部件不会变，而其组合经常变化的时候

2. 优点

• 封装性。是客户端不必知道产品内部组成的细节。
• 建造者独立，易扩展。
• 便于控制细节风险。可以对建造过程逐步细化，而不对其他模块产生任何影响。

3. 缺点

• 产品必须有共同点，范围有限制。
• 如果内部变化复杂，会有很多建造类。

4. 使用场景

相同的方法，不同的执行顺序，产生不同的事件结果时。
需要生成的对象具有复杂的内部结构时。
多个部件或零件，都可以装配到一个对象中，但产生的结果又不相同时。

5. 与工厂模式的区别

建造者模式更关注于零件装配的顺序,建造者模式一般和模板方法模式一起配合使用