又到一個新的模式了，堅持三兩天一個模式吧。好了， 不多扯這沒用的了，正式來學習我們的構建者模式。

1、使用場景：

我覺得是在其它類中不關心構建過程，在初始化之前或在初始化時需要大量設定、呼叫屬性或方法時使用。

來自百度文庫：

缺點：

建造者模式的“加工工藝”是暴露的，這樣使得建造者模式更加靈活，也使得工藝變得對客戶不透明。

優點：

  建造模式的使用使得產品的內部表象可以獨立地變化。使用建造模式可以使客戶端不必知道產品內部組成的細節。 
每一個Builder都相對獨立，而與其他的Builder無關。 模式所建造的最終產品更易於控制。

理解：

以一個造車與造船為本次的模式做理解，客戶需要一輛車，和一隻船做為交通工具。此時，客戶是不需要知道車與船是如何製造出來的，客戶只是關心需要得到車和船。

一輛能執行的車或船隻應該有發動機和燃料（如果讀者要鑽牛角尖，那我也無能為力啦），製造發動機是需要材料與工人的，對車來說，它只是需要發動機與燃料。所以在我們的構建者中需要為車準備材料與工人。管理員，對構建車或船做管理。

UML圖：

對應程式碼：

首先我們需要一個構建交通工具的抽象類（也可以是介面）

public abstract class AbstractTrafficToolsBuilding {

    protected ITrafficTools trafficTools;
    public abstract void buildingMaterial();
    public abstract void buildingWorker();
    public abstract ITrafficTools resultTrafficTools();

}
 

public class CarBuilding extends AbstractTrafficToolsBuilding {

    public CarBuilding(){
        this.trafficTools = new Car();
    }
    @Override
    public void buildingMaterial() {
        System.out.println("找到安裝車的材料....");
    }

    @Override
    public void buildingWorker() {
        System.out.println("找到安裝車的工人...");
    }

    @Override
    public ITrafficTools resultTrafficTools() {
        trafficTools.engine();
        trafficTools.elding();
        System.out.println("車輛完工...");
        return trafficTools;
    }
}
 

public class ShipBuilding extends AbstractTrafficToolsBuilding {

    public ShipBuilding(){
        this.trafficTools = new Ship();
    }
    @Override
    public void buildingMaterial() {
        System.out.println("找到安裝船的材料....");
    }

    @Override
    public void buildingWorker() {
        System.out.println("找到安裝船的工人...");
    }

    @Override
    public ITrafficTools resultTrafficTools() {
        trafficTools.engine();
        trafficTools.elding();
        System.out.println("船隻完工...");
        return trafficTools;
    }
}

交通工具的介面，一個發動機，一個燃料的方法。

public interface ITrafficTools {
    public void engine();
    public void elding();
}

兩個實現類：

public class Car implements ITrafficTools{
    @Override
    public void engine() {
        System.out.println("安裝車的發動機...");
    }

    @Override
    public void elding() {
        System.out.println("給車加入燃料...");
    }
}

public class Ship implements ITrafficTools {
    @Override
    public void engine() {
        System.out.println("安裝船的發動機...");
    }

    @Override
    public void elding() {
        System.out.println("給船加入燃料...");
    }
}

public class Director {
    public Director(AbstractTrafficToolsBuilding abstractTrafficToolsBuilding){
        this.abstractTrafficToolsBuilding = abstractTrafficToolsBuilding;
    }
    private AbstractTrafficToolsBuilding abstractTrafficToolsBuilding;

    public ITrafficTools construct(){
        abstractTrafficToolsBuilding.buildingMaterial();
        abstractTrafficToolsBuilding.buildingWorker();
        return abstractTrafficToolsBuilding.resultTrafficTools();
    }
}

public class Client {
    public static void main(String[] args) {
        //得一個輛車
        Director director = new Director(new CarBuilding());
        ITrafficTools car = director.construct();
        //得到一隻船
        Director shipDirector = new Director(new ShipBuilding());
        ITrafficTools ship = shipDirector.construct();
    }
}

這就是構建者模式。