首页 > 代码库 > 建造者模式<Builder>

建造者模式<Builder>

2024-07-04 04:40:43   221人阅读

概述

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

角色

　　建造者（Builder）：为创建一个产品对象的各个部件指定抽象接口。

　　具体建造者（ConcreteBuilder）：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并 提供一个检索产品的接口

　　产品（Product）：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

　　指挥者（Director）：指挥并构造一个使用Builder接口的对象

解读

　　UML

　　

　　C#代码

　　

  1     /// <summary>
  2     /// Build
  3     /// 提供创建各部件的接口
  4     /// </summary>
  5     public abstract class Builder
  6     {
  7         protected Person person;
  8 
  9         public abstract void BuildHead();
 10 
 11         public abstract void BuildBody();
 12 
 13         public abstract void BuildLeg();
 14 
 15         public abstract void BuildArm();
 16 
 17         public Person GetPerson()
 18         {
 19             return person;
 20         }
 21 
 22         public Person()
 23         {
 24             person=new Person();
 25         }
 26     }
 27 
 28     /// <summary>
 29     /// Product 
 30     /// 指定要建造的产品
 31     /// </summary>
 32     public class Person
 33     {
 34         public string Head
 35         {
 36             get;
 37             set;
 38         }
 39 
 40         public string Body
 41         {
 42             get;
 43             set;
 44         }
 45 
 46         public string Arm
 47         {
 48             get;
 49             set;
 50         }
 51 
 52         public string Leg
 53         {
 54             get;
 55             set;
 56         }
 57     }
 58 
 59     /// <summary>
 60     /// ConcreteBuilder
 61     /// 创建一个具体的产品 
 62     /// </summary>
 63     public class FatPersonBuilder:Builder
 64     {
 65         public override void  BuildArm()
 66         {
 67              Console.WriteLine("this is fat persion ‘s arm");
 68         }
 69 
 70         public override void  BuildBody()
 71         {
 72             Console.WriteLine("this is fat persion ‘s body");
 73         }
 74         public override void  BuildHead()
 75         {
 76             Console.WriteLine("this is fat persion ‘s head");
 77         }
 78 
 79         public override void  BuildLeg()
 80         {
 81             Console.WriteLine("this is fat persion ‘s leg");
 82         }
 83     }
 84 
 85     /// <summary>
 86     /// ConcreteBuilder
 87     /// 创建一个具体的产品 
 88     /// </summary>
 89     public class ThinPersonBuilder:Builder
 90     {
 91         public override void  BuildArm()
 92         {
 93              Console.WriteLine("this is Thin persion ‘s arm");
 94         }
 95 
 96         public override void  BuildBody()
 97         {
 98             Console.WriteLine("this is Thin persion ‘s body");

 99         }
100         public override void  BuildHead()
101         {
102             Console.WriteLine("this is Thin persion ‘s head");
103         }
104 
105         public override void  BuildLeg()
106         {
107             Console.WriteLine("this is Thin persion ‘s leg");
108         }
109     }
110 
111     /// <summary>
112     /// 指挥创建者
113     /// </summary>
114     public class PersonDirector
115     {
116         Builder build;
117         public PersonDirector(Builder build)
118         {
119             this.build=build;
120         }
121         //创建一个产品 ,并返回产品 
122         public Person BuildPerson()
123         {
124             build.BuildArm();
125             build.BuildBody();
126             build.BuildHead();
127             build.BuildLeg();
128             return build.GetPerson();
129         }
130     }
131
View Code


总结:

　　用户只需要指定要建造的类型就可以得到它们，而具体的建造过程和细节不需要知道

　　建造代码与表示相分离，如果要改变一个产品的内部表示，只要再定义一个新的具体的建造者就可以了。

 　　建造过程由指挥者来控制，建造细节由一个抽象类来控制，对于实现建造细节的具体类来说，不会遗漏某一个步骤

使用范围

　　创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时

　　当复杂对象的部件相对稳定，不会发生变化时

 

 


联系
我们