设计模式之Builder模式

发表于 | 分类于 ，

模式定义

将一个复杂对象的构建与他的表示分离，使得同样的构建过程可以创建不同的表示。

模式使用场景

  1. 相同的方法，不同的执行顺序，产生不同的时间结果时。
  2. 多个部件或零件，都可以装配到一个对象中，但是产生的结果又不相同时。
  3. 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能时。

UML图

Alt text

角色描述

* Product产品类：产品的抽象类
* Builder：抽象类，规范产品的组件，一般由子类实现具体的组装过程。
* ConcreteBuilder：具体的构造器
* Director：统一组装过程

实现

电脑组装过程比较复杂，步骤很多，但是顺序却不确定。适用于Builder模式

Computer抽象类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public abstract class Computer {
    protected int mCpuCore = 1;
    protected int mRanSize = 0;
    protected String mOs = "Dos";
    public Computer() {
    }
    public abstract void setmCpuCore(int mCpuCore);
    public abstract void setmRanSize(int mRanSize);
    public abstract void setmOs(String mOs);
    @Override
    public String toString() {
        return "Computer{" +
                "mCpuCore=" + mCpuCore +
                ", mRanSize=" + mRanSize +
                ", mOs='" + mOs + '\'' +
                '}';
    }
}

AppleComputer实现类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class AppleComputer extends Computer{
    protected AppleComputer(){
    }
    @Override
    public void setmCpuCore(int mCpuCore) {
        super.mCpuCore = mCpuCore;
    }
    @Override
    public void setmRanSize(int mRanSize) {
        super.mRanSize = mRanSize;
    }
    @Override
    public void setmOs(String mOs) {
        super.mOs = mOs;
    }
}

Builder抽象类

1
2
3
4
5
6
7
8
9
public abstract class Builder {
    public abstract void buildCPU(int core);
    public abstract void buildRAM(int gb);
    public abstract void buildOs(String os);
    public abstract Computer create();
}

AppleBuilder实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class AppleBuilder extends Builder{
    private Computer mApplePC = new AppleComputer();
    @Override
    public void buildCPU(int core) {
        mApplePC.setmCpuCore(core);
    }
    @Override
    public void buildRAM(int gb) {
        mApplePC.setmRanSize(gb);
    }
    @Override
    public void buildOs(String os) {
        mApplePC.setmOs(os);
    }
    @Override
    public Computer create() {
        return mApplePC;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Director {
    Builder builder = null;
    public Director(Builder builder) {
        this.builder = builder;
    }
    public void construct(int cpu, int ram, String os) {
        builder.buildCPU(cpu);
        builder.buildRAM(ram);
        builder.buildOs(os);
    }
}

Test

1
2
3
4
5
6
7
8
public class Test {
    public static void main(String[] args) {
        Builder builder = new AppleBuilder();
        Director director = new Director(builder);
        director.construct(4,2,"Max OS X 10.0.3");
        System.out.println(builder.create().toString());
    }
}

优点和缺点

  • 优点：

    • 良好的封装性，使用Builder模式可以使客户端不必知道产品内部组成的细节。
    • 建造者独立，容易扩展
    • 在对象创建过程中会使用到系统中的其他对象，这些对象在产品的创建过程中不易得到。

  • 缺点：

    • 会产生多余的Builder对象和Director对象，消耗内存
    • 对象的构建过程暴露。
Donate comment here