设计模式(5)-对象创建型模式-Builder模式

1.1           Builder模式

1.1.1      功能

这个模式的描述在GoF上描述的比较抽象，想做到两点：

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

这句话要分为三个部分来理解：

1).主语缺省为客户程序，是客户程序来创建复杂对象；

2).要独立于该对象的组成部分，需要builder来封装这些组成部分(组件)的实现；

3).要独立于装配方式，需要Director类来封装这些组装方式.

2.  当构造过程必须允许被构造的对象有不同的表示时

       1).对这句话的理解是：builder中的组成部分要允许传入不同的参数从而对同一个组成部分生成不同的对象.

1.1.2      结 构、参与者与协作关系

参与者：

•B u i l d e r

                — 为创建一个P r o d u c t对象的各个部件指定抽象接口。

•C o n c r e t e B u i l d e r

                — 实现Bu i l d e r的接口以构造和装配该产品的各个部件。

                — 定义并明确它所创建的表示。

                — 提供一个检索产品的接口。

•Director

                — 构造一个使用Bu i l d e r接口的对象。

•P r o d u c t

                — 表示被构造的复杂对象。C o n c r e t e B u i l d e r创建该产品的内部表示并定义它的装配过程。

                — 包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

  协作

•  客户创建D ir e c t o r对象，并用它所想要的 B u i l d e r对象进行配置。

•  一旦产品部件被生成，导向器就会通知生成器。

•  生成器处理导向器的请求，并将部件添加到该产品中。

•  客户从生成器中检索产品。

1.1.3         例子-C++

                这里例子来自GoF,其中MazeBuilder即builder类,MazeGame即director类,MazeGame的CreateMaze方法即为construct()方法.

                M a z e B u i l d e r类定义了创建各种创建迷宫部件的builder类的接口：

                Class MazeBuilder{
                public:
                                virtualvoid BuildMaze(){}
                                virtualvoid BuildRoom(int room){}
                                virtualvoid BuildDoor(int roomFrom,int roomTo){}
                                virtualMaze *GetMaze(){return 0;}

                protected:
                                MazeBuilder();

                }

                Maze*MazeGame::CreateMaze(MazeBuilder &builder)
                {

                                builder.BuildMaze();

                                builder.BuildRoom(1);

                                builder.BuildDoor(1,2);
                }

                子类StandardMazeBuilder是一个创建简单迷宫的实现,他将要创建的迷宫放在变量_CurrentMaze中。

Class StandardMazeBuilder : public MazeBuilder
{

public:
                StandardMazeBuilder();

                virtualvoid BuildMaze();

                virtualvoid BuildRoom(int);

                virtualvoid BuildDoor(int,int);

                VirtualMaze*GetMaze();

Private:

                DirectionCommonWall(Room*,Room*);

                Maze *_currentMaze;

}

 

客户现在可以使用CreateMaze和StandardMazeBuilder来创建一个迷宫：

Maze *maze;

MazeGame game;

StandardMazeBuilder builder;

game.CreateMaze(builder);

Maze=builder.GetMaze();

 

 

 

 

1.1.4      例子-Java 代码

                生产一辆汽车，生产汽车的厂家不需要知道引擎怎么生产的，不需要关心轮胎怎么生产的，也不需要关心玻璃怎么生产的。当他在生产一辆车的时候，只会说，我要一块日本产的引擎，于是就有了日本产的引擎（至于日本引擎怎么生产的他不关心，他只要一个引擎的成品），他又说我要一块美国产的玻璃，于是就有了美国产的玻璃，这样直到他得到了所有的构件，然后他把这些构件组装起来，组成一个成品（汽车）卖给客户。

/**

 *定义产品类Car

 */ 

class Car{ 

   Glass glass1; 

   Glass glass2; 

   Glass glass3; 

   Glass glass4; 

   Wheel wheel1;

   Wheel wheel2;

   Wheel wheel3;

   Wheel wheel4;

   

}

 

//定义部件类：

package DesignPattern;

 

abstractclassGlass{ 

}

 

classJapaneseGlassextends Glass{ 

   public StringtoString(){ 

       return"JapaneseGlass"; 

   } 

} 

 

class AmericanGlassextends Glass{ 

   public StringtoString(){ 

       return"AmericanGlass"; 

   } 

} 

 

 

abstractclass Wheel{ 

} 

 

class JapaneseWheelextends Wheel{ 

   public StringtoString(){ 

       return"JapaneseWheel"; 

   } 

} 

class AmericanWheelextends Wheel{ 

   public StringtoString(){ 

       return"AmericanWheel"; 

   } 

}

 

//定义 builder:

classCarABuilderimplements CarBuilder{ 

   private Carproduct=null; 

   public CarABuilder(){ 

       product=new Car(); 

   } 

 

   @Override 

   publicvoid buildGlass(int glassNo) { 

       //TODO Auto-generatedmethod stub 

      switch(glassNo)

      {

      case 1:

             product.glass1=new AmericanGlass();

             break;

      case 2:

             product.glass2=new AmericanGlass();

             break;

      case 3:

             product.glass3=new AmericanGlass();

             break;

      case 4:

             product.glass4=new AmericanGlass();

             break;              

      }

 } 

   @Override 

   publicvoid buildWheel() { 

       //TODO Auto-generatedmethod stub 

       product.wheel1=new JapaneseWheel();

       product.wheel2=new JapaneseWheel();

       product.wheel3=new JapaneseWheel();

       product.wheel4=newJapaneseWheel();       

   } 

   @Override 

   public Car getProduct(){ 

       returnproduct; 

   } 

}

 

//定义director

class Director{ 

   private CarBuilderbuilder;  

   public Director() {} 

   public Carconstruct(CarBuilder builder) {

      this.builder = builder;  

      //本车只有两块玻璃

      this.builder.buildGlass(1);

      this.builder.buildGlass(2);

       return this.builder.getProduct(); 

   }  

} 

 

package DesignPattern;

 

publicclass TestMain {

 

       /**

        *@param args

        */

       public static void main(String[] args){

              Carc=new Car();

              CarABuilderaBuilder=new CarABuilder();

              Directord=new Director();

              d.construct(aBuilder);

              c=aBuilder.getProduct();

              System.out.println("Glass1:"+c.glass1+"Glass2:"+c.glass2+" Glass3:"+c.glass3+" Glass4:"+c.glass4);

       }

}