構建者模式(Builder pattern)

TreasureBoy發表於2020-11-08
模式UI

構建者模式應用場景：

主要用來構建一些複雜物件，這裡的複雜物件比如說：在建造大樓時，需要先打牢地基，搭建框架，然後自下向上地一層一層蓋起來。通常，在建造這種複雜結構的物體時，很難一氣呵成。我們需要首先建造這個物體的各個部分，然後分階段將他們組合起來。那麼現在就出現了構建者模式：構建者模式由Builder（建造者）和Director（指揮者）組成。請看如下的UML圖：                    

                                    

 

 

Director類

package com.yuan.builder.demo1;

//指揮:核心，負責指揮構建一個工程，工程如何構建，由它決定
public class Director {

    //指揮工人給出執行順序
    public Product build(Builder builder) {
        builder.buildA();
        builder.buildC();
        builder.buildD();
        builder.buildB();
        return builder.getProduct();
    }

}

 

Builder類

 

package com.yuan.builder.demo1;
//抽象的建造者
public abstract class Builder {

    abstract  void buildA();//地基
    abstract  void buildB();//鋼筋工程
    abstract  void buildC();//鋪電線
    abstract  void buildD();//粉刷

    //完工：得到了具體的產品
    abstract  Product getProduct();
}

Worker類
package com.yuan.builder.demo1;

/**
 * 具體的建造者:工人
 */
public class Worker extends Builder  {
    private Product product;

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

    @Override
    void buildA() {
        product.setBuildA("地基");
        System.out.println("地基");
    }

    @Override
    void buildB() {
        product.setBuildB("鋼筋工程");
        System.out.println("鋼筋工程");
    }

    @Override
    void buildC() {
        product.setBuildC("鋪電線");
        System.out.println("鋪電線");
    }

    @Override
    void buildD() {
        product.setBuildD("粉刷");
        System.out.println("粉刷");
    }

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

Product類
package com.yuan.builder.demo1;
//產品：房子
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 + '\'' +
                '}';
    }
}
 Test類
package com.yuan.builder.demo1;

public class Test {
    public static void main(String[] args) {
        //指揮
        Director director = new Director();
        //指揮具體的工人完成
        Product product = director.build(new Worker());
        System.out.println(product.toString());
    }
}








 


 擴充思路：


誰知道什麼：在物件導向程式設計中，“誰知道什麼”是非常重要的。也就是說，我們需要在程式設計時注意哪個類可以適用哪些方法以及使用哪個方法到底好不好。


 設計時能夠決定的事情和不能決定的事情：Builder類中的抽象方法的定義！！！






相關文章