設計模式之建造者模式

建造者模式

建立型模式

建造者模式（Builder Pattern）使用多個簡單的對象一步一步構建成一個複雜的對象。它提供了一種建立對象的最佳方式。

一個 Builder 類會一步一步構造最終的對象。該 Builder 類是獨立於其餘對象的。

介紹

意圖：將一個複雜的構建與其表示相分離，使得一樣的構建過程能夠建立不一樣的表示。

主要解決：主要解決在軟件系統中，有時候面臨着"一個複雜對象"的建立工做，其一般由各個部分的子對象用必定的算法構成；因爲需求的變化，這個複雜對象的各個部分常常面臨着劇烈的變化，可是將它們組合在一塊兒的算法卻相對穩定。

什麼時候使用：一些基本部件不會變，而其組合常常變化的時候。

如何解決：將變與不變分離開。

關鍵代碼：建造者：建立和提供實例，導演：管理建造出來的實例的依賴關係。

應用實例： 一、去肯德基，漢堡、可樂、薯條、炸雞翅等是不變的，而其組合是常常變化的，生成出所謂的"套餐"。 二、JAVA 中的 StringBuilder。

具體實現

以蓋房子爲例

第一種（傳統模式）

public abstract class AbstractHouse {

    //打地基
    public abstract void buildBasic();
    //砌牆
    public abstract void buildWalls();
    //封頂
    public abstract void roofed();

    public void build(){
        buildBasic();
        buildWalls();
        roofed();
    }


}

public class CommonHouse extends AbstractHouse{


    @Override
    public void buildBasic() {
        System.out.println("普通房子打地基");
    }

    @Override
    public void buildWalls() {
        System.out.println("普通房子砌牆");
    }

    @Override
    public void roofed() {
        System.out.println("普通房子蓋屋頂");
    }
}

public class Client {

    public static void main(String[] args){
      CommonHouse commonHouse = new CommonHouse();
      commonHouse.build();
    }
}

優勢：

便於理解，簡單易操做。

缺點：

設計的程序結構，過於簡單，沒有設計緩存層對象，程序的擴展和維護很差，也就是說，這種設計方案，把產品（房子）和建立產品的過程（建立房子的流程）封裝在了一塊兒，加強了耦合性。

解決方案：

將產品和產品建造過程解耦 =》 建造者模式

第二種 （建造者模式）

建立一個房屋

public class House {

    private String basic;
    private String wall;
    private String roofed;

    public String getBasic() {
        return basic;
    }

    public void setBasic(String basic) {
        this.basic = basic;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }
}

建立一個抽象的建造者

public abstract class HouseBuilder {
    protected House house = new House();

    //將建造的流程寫好,抽象的方法
    public abstract void buildBasic();

    public abstract void buildWalls();

    public abstract void buildRoofed();

    public House buildHouse() {
        return house;
    }
}

建立具體實現的房屋

public class CommonHouse extends HouseBuilder {
    @Override
    public void buildBasic() {
        System.out.println("普通房子打地基5米");
    }

    @Override
    public void buildWalls() {
        System.out.println("普通房子砌牆10釐米");
    }

    @Override
    public void buildRoofed() {
        System.out.println("普通房子蓋普通屋頂");
    }
}

public class HighBuilding extends HouseBuilder {

    @Override
    public void buildBasic() {
        System.out.println("高樓打地基100米");
    }

    @Override
    public void buildWalls() {
        System.out.println("高樓的砌牆20釐米");
    }

    @Override
    public void buildRoofed() {
        System.out.println("高樓的屋頂是透明的");
    }
}

建立一個指揮者

public class HouseDirector {

    private HouseBuilder houseBuilder;

    //構造器傳入
    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    //如何處理建造房子的流程,交給指揮者
    public House constructHouse() {
        houseBuilder.buildBasic();
        houseBuilder.buildWalls();
        houseBuilder.buildRoofed();
        return houseBuilder.buildHouse();
    }
}

public class Client {

    public static void main(String[] args) {
        //蓋普通房子
        CommonHouse commonHouse = new CommonHouse();
        //準備建立房子的指揮者
        HouseDirector houseDirector = new HouseDirector(commonHouse);
        //返回房子
        House house = houseDirector.constructHouse();
    }
}

優勢：

一、建造者獨立，易擴展。 二、便於控制細節風險。

缺點：

一、產品必須有共同點，範圍有限制。 二、如內部變化複雜，會有不少的建造類。

注意事項：

與工廠模式的區別是：建造者模式更加關注與零件裝配的順序。而工廠模式更加關注是由什麼工廠來建立。