【設計模式】建造者模式(生成器模式)

使用頻率：★★☆☆☆

1、什麼是生成器模式

對複雜對象的建立過程進行抽象，相同的建立步驟，不同的建立過程實現，生成不一樣表示的對象；

例如建立一臺電腦，對其應用生成器模式進行建立：

建立過程是指建立cpu、建立內存、建立顯示器三個步驟，全部品牌電腦的建立過程都是同樣的，能夠對其抽象出一個抽象建造者角色Builder；

不一樣廠商（指的是具體的Builder實現，不一樣廠商不同）生產的電腦，表現出來是不同的；

2、適用場合

被建立的對象內部結構比較複雜，且須要一步步構造

3、角色

•  抽象建造者
• 具體建造者
• 指揮者
• 產品
• 產品消費者

說明：

具體建造者繼承抽象建造者；

指揮者用於生成具體產品對象，且指揮者有一個建造者屬性能夠設置更改；

一個指揮者，只要其建造者不同，生成的產品對象的表現也不同；

產品消費者使用指揮者生成的具體產品對象；

4、例子

demo說明：

以生產PC爲例，這裏咱們假設生產一臺PC只需三個步驟，建立cpu、建立內存、建立顯示器，將三個步驟抽象成一個Builder，且該Builder有一個建立待加工的產品的方法和返回成品的方法；

以聯想電腦和惠普電腦爲例，認爲它們在生產電腦的過程當中，以上三個步驟的實現是不一致的，對應着具體的HPBuilder和LenovoBuilder；

同時，咱們把電腦產品封裝成Computer類，其擁有cpu、內存、顯示器三個屬性；

而後，再建立一個指揮者類Director，其擁有一個建造者對象和建造PC產品的方法construct，該方法經過具體建造者對象，依次執行每一個步驟，最後返回建造完成的產品對象；

類圖：

代碼實現：

產品角色

package com.pichen.dp.creationalpattern.builder;

public class Computer {

    private String cpu;
    private String ram;
    private String monitor;
    /**
     * @return the cpu
     */
    public String getCpu() {
        return cpu;
    }
    /**
     * @param cpu the cpu to set
     */
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }
    /**
     * @return the ram
     */
    public String getRam() {
        return ram;
    }
    /**
     * @param ram the ram to set
     */
    public void setRam(String ram) {
        this.ram = ram;
    }
    /**
     * @return the monitor
     */
    public String getMonitor() {
        return monitor;
    }
    /**
     * @param monitor the monitor to set
     */
    public void setMonitor(String monitor) {
        this.monitor = monitor;
    }
    
    public String toString(){
        return "PC:" + this.cpu + ", " + this.ram + ", " + this.monitor;
    }
}

View Code

抽象建造者

package com.pichen.dp.creationalpattern.builder;

public abstract class Builder {
    private Computer pc ;
    public abstract void buildCpu();
    public abstract void buildRam();
    public abstract void buildMonitor();
    
    
    public void createComputer(){
        this.pc = new Computer();
    }
    public Computer getComputer(){
        return this.pc;
    }
}

View Code

兩個具體建造者

package com.pichen.dp.creationalpattern.builder;



public class LenovoBuilder extends Builder{
    @Override
    public void buildCpu() {
        System.out.println("lenovo: build cpu start...");
        this.getComputer().setCpu("lenovo cpu");
        System.out.println("lenovo: build cpu end...");
    }

    @Override
    public void buildRam() {
        System.out.println("lenovo: build ram start...");
        this.getComputer().setRam("lenovo ram");
        System.out.println("lenovo: build ram end...");
        
    }

    @Override
    public void buildMonitor() {
        System.out.println("lenovo: build monitor start...");
        this.getComputer().setMonitor("lenovo monitor");
        System.out.println("lenovo: build monitor end...");
        
    }
}

View Code

package com.pichen.dp.creationalpattern.builder;

public class HPBuilder extends Builder{

    @Override
    public void buildCpu() {
        System.out.println("hp: build cpu start...");
        this.getComputer().setCpu("hp cpu");
        System.out.println("hp: build cpu end...");
    }

    @Override
    public void buildRam() {
        System.out.println("hp: build ram start...");
        this.getComputer().setRam("hp ram");
        System.out.println("hp: build ram end...");
        
    }

    @Override
    public void buildMonitor() {
        System.out.println("hp: build monitor start...");
        this.getComputer().setMonitor("hp monitor");
        System.out.println("hp: build monitor end...");
        
    }

}

View Code

指揮者

package com.pichen.dp.creationalpattern.builder;

public class Director {

    private Builder builder;
    public Director(Builder builder) {
        this.builder = builder;
    }
    
    public Computer construct(){
        this.builder.createComputer();
        this.builder.buildCpu();
        this.builder.buildRam();
        this.builder.buildMonitor();
        return this.builder.getComputer();
    }

    /**
     * @return the builder
     */
    public Builder getBuilder() {
        return builder;
    }

    /**
     * @param builder the builder to set
     */
    public void setBuilder(Builder builder) {
        this.builder = builder;
    }
}

main函數

package com.pichen.dp.creationalpattern.builder;

public class Main {
    public static void main(String[] args) {
        Builder hpBuilder = new HPBuilder();
        Director director = new Director(hpBuilder);
        Computer hpPC = director.construct();
        System.out.println(hpPC.toString());
        
        Builder lenovoBuilder = new LenovoBuilder();
        director.setBuilder(lenovoBuilder);
        Computer lenovoPC = director.construct();
        System.out.println(lenovoPC.toString());
        
    }
}

運行結果以下，相同的指揮者使用不一樣的建造者建立了不一樣的產品：

links

生成器or建造者模式★★☆☆☆

抽象工廠模式★★★★★

工廠方法模式★★★★★

簡單工廠模式★★★★☆