Builder模式的使用情景

  1. 相同的方法, 不同的执行顺序, 产生不同的事件结果
  2. 多个部件或零件, 都可以装配到一个对象中, 但是产生的运行结果又不相同
  3. 产品类比较复杂, 或者产品类中的调用顺序不同产生了不同的作用.
  4. 当初始化一个对象特别复杂, 如参数多, 且很多参数都具有默认值.

Builder模式的整体构造

产品类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
abstract class Computer {
    protected String mBoard;
    protected String mDisplay;
    protected String mOS;

    protected Computer(){

    }

    public void setBoard(String board){
        mBoard=board;
    }

    public void setDisplay(String display){
        mDisplay=display;
    }

    public abstract void setOS();

    @Override
    public String toString() {
        return "Computer [mBoard="+ mBoard+", mDisplay="+mDisplay+", mOS="+mOS+"]";
    }
}


class Macbook extends Computer{
    protected Macbook(){

    }
    @Override
    public void setOS() {
        mOS="Mac OS X 10.10";
    }
}

Builder类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//抽象Builder类
abstract class Builder{

    public abstract void buildBoard(String board);
    public abstract void buildDispaly(String display);
    public abstract void buildOS();
    public abstract Computer create();
}

//具体Builder类
class MacbookBuilder extends Builder{

    private Computer mComputer=new Macbook();

    @Override
    public void buildBoard(String board) {
        mComputer.setBoard(board);
    }

    @Override
    public void buildDispaly(String display) {
        mComputer.setDisplay(display);
    }

    @Override
    public void buildOS() {
        mComputer.setOS();
    }

    @Override
    public Computer create() {
        return mComputer;
    }
}

导演类

导演类起到封装的作用, 避免高层模块深入到建造者内部的实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Direcotr{
    Builder mBuilder=null;

    public Direcotr(Builder builder){
        mBuilder=builder;
    }

    public void construct(String board,String dispaly){
        mBuilder.buildBoard(board);
        mBuilder.buildDispaly(dispaly);
        mBuilder.buildOS();
    }

}
1
2
3
4
5
6
7
8
9
10
public class BuildTest{
    public static void main(String[] args){
        Builder builder=new MacbookBuilder();

        Direcotr pcDirector=new Direcotr(builder);

        pcDirector.construct("intel","retina");
        StdOut.println("Computer Info : "+builder.create().toString());
    }
}

忽略Director类

在开发过程中, 可以忽略Director类, 直接使用Builder来进行对象的组装, 可以使用setter方法进行链式调用.
new Builder().setA("A").setB("B").create()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
public class BuildTest {
    public static void main(String[] args){
        ConcreteProductA A= (ConcreteProductA)new A_Buider().setArg_1("aa")
                                        .setArg_2("bb").create();
        StdOut.print(A);

    }
}

abstract class abstractProduct{
    protected String arg_1;
    protected String arg_2;

    protected abstract void setArg_1(String arg_1);

    protected abstract void setArg_2(String arg_2);

    @Override
    public String toString() {
        return "arg_1: "+arg_1+", arg_2: "+arg_2;
    }
}

class ConcreteProductA extends abstractProduct{

    protected void setArg_1(String arg_1){
        this.arg_1=arg_1;
    }

    protected void setArg_2(String arg_2){
        this.arg_2=arg_2;
    }
}

abstract class Builder {
    public abstract Builder setArg_1(String arg_1);

    public abstract Builder setArg_2(String arg_2);

    public abstract abstractProduct create();
}

class A_Buider extends Builder{
    private ConcreteProductA mConcreteProductA=new ConcreteProductA();

    @Override
    public Builder setArg_1(String arg_1) {
        mConcreteProductA.setArg_1(arg_1);
        return this;
    }

    @Override
    public Builder setArg_2(String arg_2) {
        mConcreteProductA.setArg_2(arg_2);
        return this;
    }

    @Override
    public abstractProduct create(){
        return mConcreteProductA;
    }
}