原文 第4章 建造者模式（Builder Pattern）

定义

将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。

实用范围

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.便于控制细节

建造者是独立的，因此可以对建造者的过程细化，而不对其它的额模块产生影响。

设计模式系列文章入口:http://www.diyibk.com/post/39.html

最新文章

  1. css3-无缝滚动
  2. Mysql修改日期，时间不变的做法
  3. [原]ubuntu14.04 网卡逻辑修改没有文件/etc/udev/rules.d/70-persistent-net.rules
  4. 读javascript高级程序设计08-引用类型之Global、Math、String
  5. 移动互联网实战--wifi定位和架构
  6. [转载]浅谈组策略设置IE受信任站点
  7. 51 nod 机器人走方格
  8. asp.net select Case条件语句的使用方法
  9. linux set,env和export
  10. [OC Foundation框架 - 20] 统计代码行数
  11. java学习之坦克大战游戏
  12. ubuntu 12.10 软件更新源列表
  13. 浏览器检测(BrowserDetect.js)使用
  14. SQLServer在多个表中都增加一个字段的方法
  15. 记一次innobackupex备份恢复数据库过程
  16. JAVA设计模式一策略模式（Strategy Pattern）
  17. 使用IDEA导出可运行的jar包，包含引用第三方jar包
  18. 推荐一个静态博客兼笔记的工具：WDTP
  19. postgresql copy的使用方式
  20. CSS background-position用法

热门文章

  1. 【原创】leetCodeOj --- Majority Element 解题报告(脍炙人口的找n个元素数组中最少重复n/2次的元素)
  2. POJ 2538 WERTYU水的问题
  3. 《深入了解mybatis原则》 MyBatis架构设计和案例研究
  4. TFS(Team Foundation Server)简介和新手入门
  5. partial 的好处
  6. S如何解决安卓DK无法下载Package问题
  7. java提高篇（十二）-----equals()
  8. RH033读书笔记(14)-Lab 15 Switching Users and Setting a Umask
  9. C# winform 实现 qq 在屏幕边缘 自动隐藏 鼠标移过去 移上去 又自动显示
  10. [原创].NET 业务框架开发实战之六 DAL的重构