简介

构造者模式使用多个简单的对象一步一步构建成一个复杂的对象，属于创建型模式，它提供了一种创建对象的最佳方式

原理

Builder 模式基于：一个对象可能有不同的组成部分，这些组成部分的不同创建对象有不同的表示，但是各个部分之间装配的方式是一致的（比如单车的装配，车轮、链条、车身、脚踏板）。

基于此，构建的过程是一样的，所以可以统一使用一个抽象接口，不同的组成部分可以由派生类来实现

作用

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

• 优点：构造者独立、易扩展、便于控制细节风险
• 缺点：Product 必须要有共同点、范围有限、内部变化复杂、会有很多构造类

使用场景

适用于以下情况：

• 当构造过程，必须允许被构造的对象有不同表示时
• 当创建建复杂对象的算法，应独立于该对象的组成部分、以及组装方式时

区别

• 和工厂模式相比，构造者模式更加关注与零件装配的顺序

实现

UML 图

解析：

• Builder ：全部创建对象过程的抽象，提供构建不同组成部分的接口，在派生类提供具体实现
• Director.Construct：调用接口函数完成对象的构建，不同部分装配的过程都是一样的，但是不同的构建方式会有不同的表示（根据多态来决定）

原则

Builder 模式的实现，基于以下面向对象设计原则：

1. 变化的部分 —> 抽象出一个基类和对应的接口函数，提供一样的接口，不同的实现
2. 使用聚合的方式，聚合会发生变化的基类，比如：Directoi 聚合了 Builder 类的指针

代码

using System;

namespace ConsoleApp2
{
    class Class7
    {
        public static void Main(string[] args)
        {
            PersonDirector dir = new PersonDirector(new ThinPersonBuilder());
            Person person = dir.BuildPerson();
            Console.WriteLine(person.Head);
            Console.WriteLine(person.Body);
            Console.WriteLine(person.Arm);
            Console.WriteLine(person.Leg);

            Console.ReadLine();
        }
    }

    // 要建造的产品
    public class Person
    {
        public string Head { get; set; }
        public string Body { get; set; }
        public string Arm { get; set; }
        public string Leg { get; set; }
    }

    // 定义创建者接口，实现者必须实现该接口中定义的所有抽象方法，防止实现者疏忽而遗漏某个部件的创建
    public abstract class Builder
    {
        protected Person Person { get; set; }
        public Builder()
        {
            Person = new Person();
        }

        // 建造头
        public abstract void BuildHead();
        // 建造身体
        public abstract void BuildBody();
        // 建造胳膊
        public abstract void BuildArm();
        // 建造腿
        public abstract void BuildLeg();

        // 返回生成好的对象，这是一个具体方法，每个子类都可以使用它来返回一个已经创建成功的对象
        public Person GetPerson()
        {
            return Person;
        }
    }

    // 建造者的具体实现，这里是要建造出一个瘦子
    public class ThinPersonBuilder : Builder
    {
        public override void BuildHead()
        {
            Person.Head = "瘦子的脑袋";
        }

        public override void BuildBody()
        {
            Person.Body = "瘦子的身体";
        }

        public override void BuildArm()
        {
            Person.Arm = "瘦子的胳膊";
        }

        public override void BuildLeg()
        {
            Person.Leg = "瘦子的腿";
        }

    }

    // 建造者的具体实现，这里是要建造出一个胖子
    public class FatPersonBuilder : Builder
    {
        public override void BuildHead()
        {
            Person.Head = "胖子的脑袋";
        }

        public override void BuildBody()
        {
            Person.Body = "胖子的身体";
        }

        public override void BuildArm()
        {
            Person.Head = "胖子的胳膊";
        }

        public override void BuildLeg()
        {
            Person.Head = "胖子的腿";
        }
    }

    // 建造者模式中的指挥者
    public class PersonDirector
    {
        Builder builder;
        public PersonDirector(Builder personBuilder)
        {
            builder = personBuilder;
        }

        // 指挥创建一个人的过程，并返回创建成功的产品
        public Person BuildPerson()
        {
            builder.BuildHead();
            builder.BuildBody();
            builder.BuildArm();
            builder.BuildLeg();

            return builder.GetPerson();
        }
    }
}

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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

代码转载：C#设计模式笔记之建造者模式（Builder Pattern）