溫故而知新 03建造者模式的實現回顧

需求：創建複雜的對象---通過簡單的對象的自由組合，返回一個完整的產品。

意圖：將一個複雜的構建與其表示相分離，使得同樣的構建過程可以創建不同的表示。

主要解決：主要解決在軟件系統中，有時候面臨着"一個複雜對象"的創建工作，其通常由各個部分的子對象用一定的算法構成；由於需求的變化，這個複雜對象的各個部分經常面臨着劇烈的變化，但是將它們組合在一起的算法卻相對穩定。

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

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

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

最基礎代碼思路：

創建一個抽象類的建造者 用來定義生產 哪些模塊

package cn.xzc.test.builderMode;


/*
* 建造者模式  創建者模式的一種
* 複雜的類通過 簡單的類 組合而來
*
*
* */
public abstract class Builder {
    abstract  void BuildeA();
    abstract  void BuildeB();
    abstract  void BuildeC();
    abstract  void BuildeD();
    abstract Product getProduct();
}

 

創建產品

 

public class Product {
    private  String buildA;
    private  String buildB;
    private  String buildC;
    private  String buildD;

    public String getBuildA() {
        return buildA;
    }

    public void setBuildA(String buildA) {
        this.buildA = buildA;
    }

    public String getBuildB() {
        return buildB;
    }

    public void setBuildB(String buildB) {
        this.buildB = buildB;
    }

    public String getBuildC() {
        return buildC;
    }

    public void setBuildC(String buildC) {
        this.buildC = buildC;
    }

    public String getBuildD() {
        return buildD;
    }

    public void setBuildD(String buildD) {
        this.buildD = buildD;
    }

    @Override
    public String toString() {
        return "product{" +
                "buildA='" + buildA + '\'' +
                ", buildB='" + buildB + '\'' +
                ", buildC='" + buildC + '\'' +
                ", buildD='" + buildD + '\'' +
                '}';
    }
}

 

建造一個工作者集成抽象類建造者用來實際生產產品

package cn.xzc.test.builderMode02.demo01;

public class Worker extends Builder{
    private Product product;

    public Worker() {
        product = new Product();
    }

    @Override
    void BuildeA() {
        product.setBuildA("A");
        System.out.println(product.getBuildA());
    }

    @Override
    void BuildeB() {
        product.setBuildB("B");
        System.out.println(product.getBuildB());
    }

    @Override
    void BuildeC() {
        product.setBuildC("C");
        System.out.println(product.getBuildC());
    }

    @Override
    void BuildeD() {
        product.setBuildD("D");
        System.out.println(product.getBuildD());
    }

    @Override
    Product getProduct(){
       return product;
    }
}

建造一個指揮者來控制生產者去生產產品

package cn.xzc.test.builderMode02.demo01;

/*
* 指揮  核心  指定生產者按一定順序去建造出產品
* */
public class Director {
    public Product build(Builder builder){
        builder.BuildeA();
        builder.BuildeB();
        builder.BuildeC();
        builder.BuildeD();

        return builder.getProduct();
    }
}

 

最後測試‘

public class TestForBuildMode {
    public static void main(String[] args) {
        Director director= new Director();
        Product build= director.build(new Worker());
        System.out.println(build);
    }

}

 

進階思考

通常我們的建造順序不需要寫死，建造的內容也需要傳參來決定，用戶作爲調用者自己決定順序和具體傳入參數。

改造建造者可以傳入參數 和返回參數

/*
* 建造者模式  創建者模式的一種
* 複雜的類通過 簡單的類 組合而來
*
*  添加傳入參數和返回值
*
* */
public abstract class Builder {
    abstract  Builder BuildeA(String msg);
    abstract  Builder BuildeB(String msg);
    abstract  Builder BuildeC(String msg);
    abstract  Builder BuildeD(String msg);
    abstract Product getProduct();
}

 

改造工作者 繼承的建造者建造產品的方法返回this 實現鏈式編程

/*
* 實現工人類來執行產品生產 返回值爲this 實現鏈式編程
* */
public class Worker extends Builder {
    private Product product;

    public Worker() {
        product = new Product();
    }


    @Override
    Builder BuildeA(String msg) {
        product.setBuildA(msg);
        return this;
    }
    @Override
    Builder BuildeB(String msg) {
        product.setBuildB(msg);
        return this;
    }

    @Override
    Builder BuildeC(String msg) {
        product.setBuildC(msg);
        return this;
    }

    @Override
    Builder BuildeD(String msg) {
        product.setBuildD(msg);
        return this;
    }

    @Override
    Product getProduct(){
       return product;
    }
}

產品給默認參數 同時可接受工作者傳參

package cn.xzc.test.builderMode02.demo02;

public class Product {
    private  String buildA = "A1";
    private  String buildB = "B1";
    private  String buildC = "C1";
    private  String buildD = "D1";

    public String getBuildA() {
        return buildA;
    }

    public void setBuildA(String buildA) {
        this.buildA = buildA;
    }

    public String getBuildB() {
        return buildB;
    }

    public void setBuildB(String buildB) {
        this.buildB = buildB;
    }

    public String getBuildC() {
        return buildC;
    }

    public void setBuildC(String buildC) {
        this.buildC = buildC;
    }

    public String getBuildD() {
        return buildD;
    }

    public void setBuildD(String buildD) {
        this.buildD = buildD;
    }

    @Override
    public String toString() {
        return "product{" +
                "buildA='" + buildA + '\'' +
                ", buildB='" + buildB + '\'' +
                ", buildC='" + buildC + '\'' +
                ", buildD='" + buildD + '\'' +
                '}';
    }
}

 

最後測試

public class TestForBuildMode {
    public static void main(String[] args) {
        Worker worker= new Worker();
        Product product = worker.BuildeA("f").BuildeD("g").BuildeC("c").getProduct();
        System.out.println(product.toString());
    }
}