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

一、什么是生成器模式

对复杂对象的创建过程进行抽象，相同的创建步骤，不一样的创建过程实现，生成不同表示的对象；

例如创建一台电脑，对其应用生成器模式进行创建：

创建过程是指创建cpu、创建内存、创建显示器三个步骤，所有品牌电脑的创建过程都是一样的，可以对其抽象出一个抽象建造者角色Builder；

不同厂商（指的是具体的Builder实现，不同厂商不一样）生产的电脑，表现出来是不一样的；

二、适用场合

被创建的对象内部结构比较复杂，且需要一步步构造

三、角色

•  抽象建造者
• 具体建造者
• 指挥者
• 产品
• 产品消费者

说明：

具体建造者继承抽象建造者；

指挥者用于生成具体产品对象，且指挥者有一个建造者属性可以设置更改；

一个指挥者，只要其建造者不一样，生成的产品对象的表现也不一样；

产品消费者使用指挥者生成的具体产品对象；

四、例子

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建造者模式★★☆☆☆

抽象工厂模式★★★★★

工厂方法模式★★★★★

简单工厂模式★★★★☆