Java设计模式—建造者模式

当创建一个对象需要很多步骤时，建造者模式很适合。类同工厂模式，但是工厂模式更加适用于只需要一个步骤就可以创建一个对象的情况。

定义：将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示。建造者模式中每个产品的建造会遵循同样的流程，不过流程内的每一个步骤可能不相同。

建造模式将复杂的构造产品对象的过程封装在内部，用户只需要使用Director和ConcreteBuilder就能完成一个产品的构建。

角色：

1. Builder：为一个产品创建提供各个创建抽象接口；

2. ConcreteBuilder：实现了Builder接口，定义和完成了各个构建过程，提供一个获取产品的接口；

3. Director：建造者，使用Builder；

4. Product：被构造的对象。

示例代码：

1
2
3
4
5
6
7
8
9
10
//Builder
public interface Builder {

    void buildName();
    void buildAge();
    void buildWidth();
    void buileHeight();

    Product buildProduct();
}
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
public class ProductBuilder implements Builder {

    Product product;

    public ProductBuilder(){
        product = new Product();
    }

    @Override
    public void buildAge() {
        product.setAge(5);
    }

    @Override
    public void buildName() {
        product.setName("Benz");
    }

    @Override
    public void buildWidth() {
        product.setWidth(2.55f);
    }

    @Override
    public void buileHeight() {
        product.setHeight(1.50f);
    }

    @Override
    public Product buildProduct() {
        return product;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//Director
public class Director {

    private Builder builder;

    public Director(Builder builder){
        this.builder = builder;
    }

    public Product makeProduct(){
        builder.buildAge();
        builder.buildName();
        builder.buildWidth();
        builder.buileHeight();
        return builder.buildProduct();
    }
}
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
//Product
public class Product {

    private String name;
    private int age;
    private float width;
    private float height;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public float getWidth() {
        return width;
    }

    public void setWidth(float width) {
        this.width = width;
    }

    public float getHeight() {
        return height;
    }

    public void setHeight(float height) {
        this.height = height;
    }

}

客户使用代码：

1
2
3
4
5
6
Director director = new Director(new ProductBuilder());
Product product = director.makeProduct();
Log.d("Product-name", product.getName());
Log.d("Product-age", product.getAge() + "");
Log.d("Product-height", product.getHeight() + "");
Log.d("Product-width", product.getWidth() + "");

上例代码中建造一辆名为Benz的Product，使用建造者模式很好的将Product中的部件、属性和组装过程分开。