定义
将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。
实用范围
1 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2 当构造过程必须允许被构造的对象有不同表示时。
角色
在这样的设计模式中，有以下几个角色：
1 builder：为创建一个产品对象的各个部件指定抽象接口。
2 ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并 提供一个检索产品的接口。
3 Director：构造一个使用Builder接口的对象。
4 Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。
类关系图
举个简单的例子：我要需要造一个男人跟一个女孩
1.先定义一个人，跟男人女孩的具体实现
|
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
|
//人
public
class
Person
{
//头
private
String head;
//身体
private
String body;
//脚
private
String foot;
public
String getHead()
{
return
head;
}
public
void
setHead(String head)
{
this
.head = head;
}
public
String getBody()
{
return
body;
}
public
void
setBody(String body)
{
this
.body = body;
}
public
String getFoot()
{
return
foot;
}
public
void
setFoot(String foot)
{
this
.foot = foot;
}
}
//男人 product产品类
public
class
Man : Person
{
}
//女孩 product产品类
public
class
girl : Person
{
}
|
2.抽象一个建造的工具，及具体的建造过程
|
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
|
//Builder 抽象建造者
public
interface
PersonBuilder
{
void
buildHead();
void
buildBody();
void
buildFoot();
Person buildPerson();
}
//ConcreteBuilder 具体建造者
public
class
ManBuilder : PersonBuilder
{
Person person;
public
ManBuilder()
{
person =
new
Man();
}
public
void
buildBody()
{
person.setBody(
"建造男人的身体"
);
}
public
void
buildFoot()
{
person.setFoot(
"建造男人的脚"
);
}
public
void
buildHead()
{
person.setHead(
"建造男人的头"
);
}
public
Person buildPerson()
{
return
person;
}
}
public
class
GirlBuilder : PersonBuilder
{
Person person;
public
GirlBuilder()
{
person =
new
Man();
}
public
void
buildBody()
{
person.setBody(
"建造女孩的身体"
);
}
public
void
buildFoot()
{
person.setFoot(
"建造女孩的脚"
);
}
public
void
buildHead()
{
person.setHead(
"建造女孩的头"
);
}
public
Person buildPerson()
{
return
person;
}
}
|
3.最后建立一个场景，导演，或者是跟客户进行沟通的人
|
1
2
3
4
5
6
7
8
9
10
11
|
// Director类
public
class
PersonDirector
{
public
Person constructPerson(PersonBuilder pb)
{
pb.buildHead();
pb.buildBody();
pb.buildFoot();
return
pb.buildPerson();
}
}
|
4.根据客户的需求 给于不同的产品，比如需要一个男人，或者需要一个女人。
|
1
2
3
4
5
6
7
8
9
10
11
|
class
Program
{
static
void
Main(
string
[] args)
{
//建造一个男人
Person man =
new
PersonDirector().constructPerson(
new
ManBuilder());
//建造一个女孩
Person girl =
new
PersonDirector().constructPerson(
new
GirlBuilder());
}
}
|
上面仅仅是建造者模式中的一种用法，不同的需求有很多种不同的用法，举例多了反而容易混。理解里面的核心就行了 ，建造者：就是不用管我怎么去建造的，告诉我你想要什么，我就内部加工，建造好了给你。
扩展
建造者演化的其它方式：
1.省略抽象建造者角色
|
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
|
// Director类
public
class
PersonDirector
{
//获取男人
public
Person GetManPerson()
{
ManBuilder pb=
new
ManBuilder ();
pb.buildHead();
pb.buildBody();
pb.buildFoot();
return
pb.buildPerson();
}
//获取女孩
public
Person GetGirlPerson()
{
GirlBuilder pb=
new
GirlBuilder ();
pb.buildHead();
pb.buildBody();
pb.buildFoot();
return
pb.buildPerson();
}
}
//client
class
Program
{
static
void
Main(
string
[] args)
{
//建造一个男人
Person man =
new
PersonDirector().GetManPerson;
//建造一个女孩
Person girl =
new
PersonDirector().GetManPerson;
}
}
|
2.省略指导者角色
在具体建造者只有一个的情况下，如果抽象建造者角色已经被省略掉，那么还可以省略掉指导者角色，让Builder自己扮演指导者和建造者双重角色 //client
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class
Program
{
static
void
Main(
string
[] args)
{
//建造一个男人
ManBuilder pb=
new
ManBuilder ();
pb.buildHead();
pb.buildBody();
pb.buildFoot();
pb.buildPerson();
}
}
|
看到这之后 你有没发现，其实自己在开发的过程中进行的一些封装调用，用的就是建造者模式。O(∩_∩)O哈哈~ 不要怀疑你的眼睛。其实你已经早就在用了
优点
1.封装性：
使用建造者模式可以使客户端不必知道产品内部组成的细节。
2.独立，容易扩展
3.便于控制细节
建造者是独立的，因此可以对建造者的过程细化，而不对其它的额模块产生影响。
