设计模式学习之建造者模式

建造者模式的定义：将一个复杂对象构建与它的表示分离，使得一样的构建过程能够建立不一样的表示

建造者模式，保证了流程的肯定性，而流程内部的实现细节，是可继承扩展的。从根源上解决了流程不规范的问题。

建造者模式通用类图：

在建造者模式中有以下4个角色：

1. Product产品类：一般是实现了模版方法模式也就是有模版方法和基本方法
2. Builder抽象建造者：规范产品的组建，通常是由子类实现
3. ConcreteBuilder具体的建造者：实现抽象类定义的因此方法，而且返回一个组建好的对象。
4. Director导演类：负责安排已有模块的顺序，告诉Builder开始建造

建造者模式的优势：

1. 封装性
2. 建造者独立，容易扩展
3. 便于控制细节风险

建造者模式使用的场景：

1. 相同的方法，不一样的执行顺序，产生不一样的时间结果
2. 多个部件或零件，均可以装配到一个对象中，可是产生的运行结果又不相同
3. 产品类很是复杂

实现一个建造者模式Demo,类图以下：

/**
 * @author Lin
 * @Date 2018/1/5.
 */
public abstract class CarModel {

    /**
     * 这个参数是各个基本方法的执行顺序
     */
    private ArrayList<String> sequences = new ArrayList<>();

    /**
     * 启动
     */
    protected abstract void start();

    /**
     * 中止
     */
    protected abstract void stop();

    /**
     * 按喇叭
     */
    protected abstract void alarm();

    /**
     * 发动机响声
     */
    protected abstract void engineBoom();

    /**
     * 按照不一样的设定运行
     */
    final public void run(){
        for (String sequence : sequences){
            if(sequence.equals("start")){
                this.start();
            }else if(sequence.equals("stop")){
                this.stop();
            }else if(sequence.equals("alarm")){
                this.alarm();
            }else if(sequence.equals("engine")){
                this.engineBoom();
            }
        }
    }

    final public void setSequences(ArrayList<String> sequences){
        this.sequences = sequences;
    }
}

具体产品类实现：

/**
 * @author Lin
 * @Date 2018/1/5.
 */
public class BenzModel extends CarModel{

    @Override
    protected void start() {
        System.out.println("奔驰车启动...");
    }

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

    @Override
    protected void alarm() {
        System.out.println("奔驰车按喇叭....");
    }

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


/**
 * @author Lin
 * @Date 2018/1/5.
 */
public class BMWModel extends CarModel{

    @Override
    protected void start() {
        System.out.println("宝马车启动...");
    }

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

    @Override
    protected void alarm() {
        System.out.println("宝马车按喇叭....");
    }

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

抽象建造者：

import java.util.ArrayList;

/**
 * @author Lin
 * @Date 2018/1/5.
 */
public abstract class CarBuilder {
    /**
     * 设计启动顺序
     * @param sequences
     */
    public abstract void setSequences(ArrayList<String> sequences);

    /**
     * 设置完成后，获取车辆
     * @return
     */
    public abstract CarModel getCarModel();
}

具体建造者实现：

import java.util.ArrayList;

/**
 * @author Lin
 * @Date 2018/1/5.
 */
public class BenzBuilder extends CarBuilder{

    private BenzModel benz = new BenzModel();

    @Override
    public void setSequences(ArrayList<String> sequences) {
        benz.setSequences(sequences);
    }

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


import java.util.ArrayList;

/**
 * @author Lin
 * @Date 2018/1/5.
 */
public class BMWBuilder extends CarBuilder{

    private BMWModel bmw = new BMWModel();

    @Override
    public void setSequences(ArrayList<String> sequences) {
        bmw.setSequences(sequences);
    }

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

导演类：

import java.util.ArrayList;

/**
 * @author Lin
 * @Date 2018/1/5.
 */
public class Client {

    public static void main(String[] args) {
        ArrayList<String> benzSequences = new ArrayList<>();
        benzSequences.add("engine");
        benzSequences.add("start");
        benzSequences.add("alarm");
        benzSequences.add("stop");
        BenzBuilder benzBuilder = new BenzBuilder();
        benzBuilder.setSequences(benzSequences);
        BenzModel benz = (BenzModel) benzBuilder.getCarModel();
        benz.run();

        ArrayList<String> bmwSequences = new ArrayList<>();
        bmwSequences.add("start");
        bmwSequences.add("engine");
        bmwSequences.add("alarm");
        bmwSequences.add("stop");
        BMWBuilder bmwBuilder = new BMWBuilder();
        bmwBuilder.setSequences(bmwSequences);
        BMWModel bmw = (BMWModel)bmwBuilder.getCarModel();
        bmw.run();
    }
}

建造者模式的注意事项：

     建造者模式关注的是零件类型和装配工艺（顺序），这是它与工厂方法模式最大的不一样。虽然同为建立类模式，可是关注重点不同。