首页 > 代码库 > 第4章 建造者模式（Builder Pattern）

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

2024-07-03 23:42:06   225人阅读

原文 第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


联系
我们