設計模式學習之建造者模式

建造者模式的定義：將一個複雜對象構建與它的表示分離，使得一樣的構建過程能夠建立不一樣的表示

建造者模式，保證了流程的肯定性，而流程內部的實現細節，是可繼承擴展的。從根源上解決了流程不規範的問題。

建造者模式通用類圖：

在建造者模式中有以下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();
    }
}

建造者模式的注意事項：

     建造者模式關注的是零件類型和裝配工藝（順序），這是它與工廠方法模式最大的不一樣。雖然同爲建立類模式，可是關注重點不同。