設計模式------建造者模式

大話設計模式學習筆記 - 建造者模式

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

　　建造者模式能夠將一個產品的表象展現與產品的生成過程分離，從而使一個建造過程生成具備不一樣的內部表象的產品對象。若是使用了建造者模式，那麼就只須要指定須要建造的類型就能夠獲得他們，而具體的建造過程和細節就不須要知道了。

建造者模式結構圖以下：

說明：

　　建造者模式主要用於建立一些複雜的對象，這些對象內部構建間的建造順序一般是穩定的，但對象內部的構建一般面臨着複雜的變化。

　　建造者模式的好處是使建造代碼與表示代碼分離，因爲建造者隱藏了該產品是如何組裝的，因此若須要改變一個產品的內部表示，只須要再定義一個具體的建造者（ConcreateBuilder）就能夠。

示例代碼：

　　例：假設有一個畫小人的需求，需求中有可能須要各類各樣的小人，好比瘦的，胖的，高的，矮的，醜的，漂亮的。。。。

　　因爲這個比較簡單，代碼中沒有寫過多的註釋。具體代碼下面有git地址，能夠下載到本地嘗試，一看就懂。

　　產品類：即小人

public class PersonProduct {
    private String head;
    private String body;
    private String leftArm;
    private String rightArm;
    private String leftLeg;
    private String rightLeg;

    /**
     * 展現全部產品
     */
    public void show(){
        System.out.println("當前產品爲：" + this.toString());
    }
}
建造者抽象類：即builder，建立小人的通用步驟

public abstract class PersonBuilder {

    public String head;
    public String body;
    public String leftArm;
    public String rightArm;
    public String leftLeg;
    public String rightLeg;

    public PersonBuilder(String head, String body, String leftArm, String rightArm, String leftLeg, String rightLeg) {
        this.head = head;
        this.body = body;
        this.leftArm = leftArm;
        this.rightArm = rightArm;
        this.leftLeg = leftLeg;
        this.rightLeg = rightLeg;
    }

    /**
     * 建立小人的頭
     * @param head 頭
     */
    public abstract void buildHead(String head);

    /**
     * 建立小人的身體
     * @param body 身體
     */
    public abstract void buildBody(String body);

    /**
     * 建立左臂
     * @param leftArm 左臂
     */
    public abstract void buildLeftArm(String leftArm);

    /**
     * 建立右臂
     * @param rightArm 右臂
     */
    public abstract void buildRightArm(String rightArm);

    /**
     * 建立左腿
     * @param leftLeg 左腿
     */
    public abstract void buildLeftLeg(String leftLeg);

    /**
     * 建立右腿
     * @param rightLeg 右腿
     */
    public abstract void buildRightLeg(String rightLeg);

    /**
     * 得到建造以後的結果
     * @return
     */
    public abstract PersonProduct getProduct();

}
建造瘦小人的具體建立類：即concreate

public class ThinPersonBuilder extends PersonBuilder {

    private final String thinPerson = "建造瘦小人：";
    private PersonProduct product = new PersonProduct();

    public ThinPersonBuilder(String head, String body, String leftArm, String rightArm, String leftLeg, String rightLeg) {
        super(head, body, leftArm, rightArm, leftLeg, rightLeg);
    }

    @Override
    public void buildHead(String head) {
        System.out.println(thinPerson + head);

    }

    @Override
    public void buildBody(String body) {
        System.out.println(thinPerson + body);
        product.setBody(body);
    }

    @Override
    public void buildLeftArm(String leftArm) {
        System.out.println(thinPerson + leftArm);
        product.setLeftArm(leftArm);
    }

    @Override
    public void buildRightArm(String rightArm) {
        System.out.println(thinPerson + rightArm);
        product.setRightArm(rightArm);
    }

    @Override
    public void buildLeftLeg(String leftLeg) {
        System.out.println(thinPerson + leftLeg);
        product.setLeftLeg(leftLeg);
    }

    @Override
    public void buildRightLeg(String rightLeg) {
        System.out.println(thinPerson + rightLeg);
        product.setRightLeg(rightLeg);
    }

    @Override
    public PersonProduct getProduct() {
        return product;
    }
}
胖小人具體建造類

public class FatPersonBuilder extends PersonBuilder {

    private final String fatPerson = "建造胖小人：";

    public FatPersonBuilder(String head, String body, String leftArm, String rightArm, String leftLeg, String rightLeg) {
        super(head, body, leftArm, rightArm, leftLeg, rightLeg);
    }
    private PersonProduct product = new PersonProduct();

    @Override
    public void buildHead(String head) {
        System.out.println(fatPerson + head);
        product.setHead(head);
    }

    @Override
    public void buildBody(String body) {
        System.out.println(fatPerson + body);
        product.setBody(body);
    }

    @Override
    public void buildLeftArm(String leftArm) {
        System.out.println(fatPerson + leftArm);
        product.setLeftArm(leftArm);
    }

    @Override
    public void buildRightArm(String rightArm) {
        System.out.println(fatPerson + rightArm);
        product.setRightArm(rightArm);
    }

    @Override
    public void buildLeftLeg(String leftLeg) {
        System.out.println(fatPerson + leftLeg);
        product.setLeftLeg(leftLeg);
    }

    @Override
    public void buildRightLeg(String rightLeg) {
        System.out.println(fatPerson + rightLeg);
        product.setRightLeg(rightLeg);
    }

    @Override
    public PersonProduct getProduct() {
        return product;
    }
}
執行者類：即director

public class PersonDirector {
    
    public void createPerson(PersonBuilder builder){
        builder.buildHead(builder.head);
        builder.buildBody(builder.body);
        builder.buildLeftArm(builder.leftArm);
        builder.buildRightArm(builder.rightArm);
        builder.buildLeftLeg(builder.leftLeg);
        builder.buildRightLeg(builder.rightLeg);
    }
}
客戶端實現：

public class BuilderApplication {

    public static void main(String[] args) {
        ThinPersonBuilder thinPersonBuilder = new ThinPersonBuilder("thinHead","thinBody","thinLeftArm",
                                                                    "thinRightArm","thinLeftLeg","thinRightLeg");
        FatPersonBuilder fatPersonBuilder = new FatPersonBuilder("thinHead","thinBody","thinLeftArm",
                "thinRightArm","thinLeftLeg","thinRightLeg");
        PersonDirector director = new PersonDirector();

        director.createPerson(thinPersonBuilder);
        PersonProduct thinProduct = thinPersonBuilder.getProduct();
        thinProduct.show();

        director.createPerson(fatPersonBuilder);
        PersonProduct fatProduct = fatPersonBuilder.getProduct();
        fatProduct.show();
    }

}

　　git地址：https://gitee.com/Gggoblin/design.pattern.git                         builder分支

 

應用：

　　建造者模式是在當建立複雜對象的算法應該獨立於該對象的組成部分以及它們的裝配方式時適用的模式。