盖房项目需求

1. 需要建造房子经历这些过程：打桩、砌墙、封顶
2. 房子有多种类别，比如普通房、高楼、别墅；这些房子建造过程一样但是每个过程的建造手段不同

传统方式

/***
 * @author shaofan
 * @Description 传统方法解决盖房问题
 */
public class BuildHouse {
    public static void main(String[] args) {
        AbstractHouse house = new CommonHouse();
        house.build();
    }
}

/***
 * 房子抽象
 */
abstract class AbstractHouse{
    /**
     * 盖房过程，模板模式
     */
    void build(){
        buildBasic();
        buildWall();
        roofed();
    }
    abstract void buildBasic();
    abstract void buildWall();
    abstract void roofed();
}

/***
 * 普通房子
 */
class CommonHouse extends AbstractHouse{

    @Override
    void buildBasic() {
        System.out.println("普通房子打地基");
    }

    @Override
    void buildWall() {
        System.out.println("普通房子砌墙");
    }

    @Override
    void roofed() {
        System.out.println("普通房子封顶");
    }
}
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

问题分析

1. 设计的程序结构过于简单，没有设计缓存层对象，程序的扩展和维护不好，这种设计方案将房子本身和创建房子的过程封装在一起，耦合性增强
2. 需要将产品和产品建造过程解耦就需要用到建造者模式

建造者模式

基本介绍

1. 建造者模式又叫生成器模式，是一种对象构建模式。他可以将复杂对象的构建过程抽象出来，是这个抽象过程的不同实现方式可以构造出不同表现的对象
2. 建造者模式是一步步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以和构建他们，不用关注内部的构建细节

建造者模式的四个角色

1. Product：一个具体的产品对象
2. Builder：创建一个Product对象的各个部件指定的接口/抽象类
3. ConcreteBuilder：具体建造者，实现接口，构建和装配各个部件
4. Director：构建一个使用Builder接口的对象，它主要是用于创建一个复杂对象，它主要有两个作用，一是：隔离了客户与对象的生产过程；二是：负责控制产品对象的生产过程

建造者模式解决盖房问题

/***
 * @author shaofan
 * @Description 建造者模式解决盖房问题
 */
public class BuildHouse {
    public static void main(String[] args) {
        CommonBuilder commonBuilder = new CommonBuilder();
        Director director = new Director(commonBuilder);
        House house = director.build();
    }
}

class House{

}

/***
 * 建造者抽象
 */
abstract class Builder{
    protected House house = new House();
    abstract void buildBasic();
    abstract void buildWall();
    abstract void roofed();
    public House buildHouse(){
        return house;
    }
}

/***
 * 普通房屋建造者
 */
class CommonBuilder extends Builder{

    @Override
    void buildBasic() {
        System.out.println("common build basic");
    }

    @Override
    void buildWall() {
        System.out.println("common build wall");
    }

    @Override
    void roofed() {
        System.out.println("common roofed");
    }
}

/***
 * 高楼建造者
 */
class HighBuilder extends Builder{

    @Override
    void buildBasic() {
        System.out.println("high build basic");
    }

    @Override
    void buildWall() {
        System.out.println("high build wall");
    }

    @Override
    void roofed() {
        System.out.println("high roofed");
    }
}

/***
 * 指挥者，负责组合各个建造流程
 */
class Director{
    private Builder houseBuilder;
    public Director(Builder houseBuilder){
        this.houseBuilder = houseBuilder;
    }
    public void setHouseBuilder(Builder houseBuilder){
        this.houseBuilder = houseBuilder;
    }
    public House build(){
        houseBuilder.buildBasic();
        houseBuilder.buildWall();
        houseBuilder.roofed();
        return houseBuilder.buildHouse();
    }
}
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

源码分析

在jdk中java.lang.StringBuilder就是用了建造者模式

• Appendable接口定义了多个append方法，即Appendable为抽象建造者，定义了抽象方法
• AbstractStringBuilder实现了Appendable接口方法，这个AbstractStringBuilder已经是建造者，只是他不能实例化
• StringBuilder充当了指挥者的角色，同时替代AbstractStringBuilder充当了具体的建造者，建造方法的实现是由AbstractStringBuilder完成的，在StringBuilder中的Override仅仅是调用了父类的方法

总结

1. 客户端不必知道产品内部组成的细节，将产品本身和产品的创建过程解耦，是的相同的创建过程可以创建不同的产品对象
2. 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便的低缓具体建造者或增加新的具体建造者，用户是不同的具体建造者即可得到不同的产品对象
3. 可以更加精细的控制产品的创建过程，将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程
4. 增加新的具体建造者无需修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合开闭原则