設計模式-建造者模式

建造者模式也叫生成器模式。

1、定義

Separate the construction of a complex object from its representation so that the same construction process can create different representations

將一個複雜對象的構建與它的表示分離，使得同樣的構建過程可以創建不同的表示。

2、類圖

3、角色

Product：產品類。通常是實現了模板方法模式，也就是有模板方法和基本方法。

Builder：抽象構造者。規範產品的組建，一般由子類實現。

ConcreteBuilder：具體構造者。實現抽象類定義的所有方法，並且返回一個組件好的對象。

Director：導演類。負責安排已有模塊的順序，然後告訴builder開始建造。

4、例子

Product：

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("engineBoom")) {
                this.engineBoom();
            }
        }
    }

    //允許客戶自己設置一個順序
    final public void setSequence(ArrayList<String> sequence) {
        this.sequence = sequence;
    }


}

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

    @Override
    protected void stop() {
        System.out.println("Benz stop");
    }

    @Override
    protected void alarm() {
        System.out.println("Benz alarm");
    }

    @Override
    protected void engineBoom() {
        System.out.println("Benz engineBoom");
    }
}

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

    @Override
    protected void stop() {
        System.out.println("BMW stop");
    }

    @Override
    protected void alarm() {
        System.out.println("BMW alarm");
    }

    @Override
    protected void engineBoom() {
        System.out.println("BMW engineBoom");
    }
}

Builder：

public abstract class CarBuilder {
    public abstract void setSequence(ArrayList<String> sequence);

    public abstract CarModel getCarModel();
}

public class BenzBuilder extends CarBuilder {
    private BenzModel mBenzModel = new BenzModel();
    @Override
    public void setSequence(ArrayList<String> sequence) {
        this.mBenzModel.setSequence(sequence);
    }

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

public class BMWBuilder extends CarBuilder {
    private BMWModel mBMWModel = new BMWModel();
    @Override
    public void setSequence(ArrayList<String> sequence) {
        this.mBMWModel.setSequence(sequence);
    }

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

Director：

public class Director {

    private ArrayList<String> sequence = new ArrayList<String>();
    private BenzBuilder benzBuilder = new BenzBuilder();
    private BMWBuilder bmwBuilder = new BMWBuilder();

    public BenzModel getABenzModel(){
        this.sequence.clear();
        this.sequence.add("stop");
        this.sequence.add("engineBoom");
        this.sequence.add("start");
        this.benzBuilder.setSequence(sequence);

        return (BenzModel) this.benzBuilder.getCarModel();
    }

    public BMWModel getABMWModel(){
        this.sequence.clear();
        this.sequence.add("start");
        this.sequence.add("engineBoom");
        this.sequence.add("stop");
        this.bmwBuilder.setSequence(sequence);

        return (BMWModel) this.bmwBuilder.getCarModel();
    }

}

使用：

System.out.println("-----------------------------------");

Director director = new Director();
BenzModel aBenzModel = director.getABenzModel();
aBenzModel.run();
  System.out.println("------------------------------------");

Director director1 = new Director();
BMWModel abmwModel = director1.getABMWModel();
abmwModel.run();

輸出：

I/System.out: -----------------------------------
I/System.out: Benz stop
I/System.out: Benz engineBoom
I/System.out: Benz start
I/System.out: ------------------------------------
I/System.out: BMW start
I/System.out: BMW engineBoom
I/System.out: BMW stop

5、優缺點

封裝性：使用建造者模式可以使客戶端不必知道產品內部組成的細節，如例子中我們就不需要關 心每一個具體的模型內部是如何實現的，產生的對象類型就是CarModel。
 建造者獨立，容易擴展：BenzBuilder和BMWBuilder是相互獨立的，對系統的擴展非常有利。
便於控制細節風險：由於具體的建造者是獨立的，因此可以對建造過程逐步細化，而不對其他的模塊產生任何影響。

6、使用場景

a、相同的方法，不同的執行順序，產生不同的事件結果時，可以採用建造者模式。
b、多個部件或零件，都可以裝配到一個對象中，但是產生的運行結果又不相同時，則可以使用該模式。
c、產品類非常複雜，或者產品類中的調用順序不同產生了不同的效能，這個時候使用建造者模式非常合適。
d、在對象創建過程中會使用到系統中的一些其他對象，這些對象在產品對象的創建過程中不易得到時，也可以採用建造者模式封裝該對象的創建過程。該種場景只能是一個補償方法，因爲一個對象不容易獲得，而在設計階段竟然沒有發覺，而要通過創建者模式柔化創建過程，本身已經違反設計的最初目標。

7、注意事項

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

在使用建造者模式的時候考慮一下模板方法模式，別孤立地思考一個模式，僵化地套用一個模式會讓你受害無窮！