步步为营之——建造者模式(Builder)

Builder模式的定义是：将一个复杂对象的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。 

首先它意图是要构建一个复杂的对像，而这个复杂的对像往往需要由好几个子对像或分步聚来完成最终的这个对象的构建，而这个复杂对象的子对像经常需要不断的变化，但它的构建过程是相对是稳定的。

比如：一部汽车：它由发动机，轮胎、底盘，车身组成。而此时无论我最终构建的汽车是大众牌的汽车还是奥迪汽车，它的构建过程是不会变的，都是由发动机，轮胎、底盘，车身组成。至于大众牌的汽车还是奥迪汽车它们各自采用的是什么样的发动机，轮胎、地盘这些肯定是不一样的，也就是经常变化的。

通过对上面的分析,我们能够得出其下代码：

 1 public abstract class BuilderCar
 2     {
 3         public abstract void Engine();//发动机
 4         public abstract void Chassis();//底盘
 5         public abstract void Carbody();//车身
 6         public abstract void Tire();//轮胎
 7 
 8 
 9         public abstract Car GetCar();//最终构建出来的汽车
10       
11     }
12 
13     public abstract class Car {} 

 

14     

 

 接下来就是我们的逻辑代码了

  

1 public class ClentBLL 

 2     { 
 3         private BuilderCar buildercar=null;
 4         public ClentBLL(BuilderCar buildercar)
 5         {
 6             this.buildercar = buildercar;
 7         }
 8 
 9         public Car BuilderCar()
10         {
11             buildercar.Carbody();//车身
12             buildercar.Chassis();//底盘
13             buildercar.Engine();//发动机
14             buildercar.Tire();//轮胎
15 
16             return buildercar.GetCar();
17         }

 现在我们来构建一台奥迪车。

  1     //构建一台奥迪汽车

 2     public class OOOOCar:Car 
 3     { 
 4         
 5     }
 6 
 7 
 8     public class OOOOBuilderCar : BuilderCar
 9     {
10         public  void Engine(){
11             //发动机
12             //在这你随便弄什么样的发动机都可以，。
13         }
14         public  void Chassis(){}
15         public void Carbody() { }
16         public  void Tire();
17 
18 
19         public  Car GetCar() { 
20             //这块也许会用到上面这些部件方法
21                 //做一些其它的事情。
22 
23          return    new OOOOCar();//生成最终的汽车
24         
25         }

 调用代码：

  1  public class APP

2     {
3         public static void Main()
4         {
5             ClentBLL cbll = new ClentBLL(new OOOOBuilderCar());//如果想换成其它品牌的车子，只需改动这块
6         }
7     }

 其它不难发现Builder模式与Abstract Factory模式在代码上有一定的相似性，但是它们解决的问题还有一定的差别的。

  Builder模式主要解决"复杂对象各个部分"的频繁需求变动。

  Abstract Factory模式解决“系列对象”的需求变化。

它们相同的地方都是：抽象体内的对象或过程是稳定不变的，至于在项目中使用哪一个，这就要具体分析了。 

 

转载于:https://www.cnblogs.com/qgf522/archive/2012/04/12/2443404.html