builder 模式

本文中我将采用生产汽车的例子来讲解builder 模式。

考虑如下问题：我要建造一部车，我们希望将这个复杂的对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。譬如桑塔纳，帕萨特等车，采用同一各构建过程就可构建同一对象的不同表示。

比较abstract factory和builder不同点是：（1）适用问题（2）构建方式。

builder                是构造一个复杂对象;                    （适用问题）
                       一步一步的构建并最终返回一个产品；     （构建方式）

abstract factory       是侧重于多个系列产品（一个复杂对象）;  （适用问题）
                       产品是立即返回的                       （构建方式）

正如以上所说，以下问题可以采用builder 模式。

[当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式]
：考虑我们的例子：车间将要装配桑塔纳轿车，我们可以一步步的装配好轿车产品。

[当构造过程允许被构造的对象有不同表示]
：如果我们我们需要装配桑塔纳轿车现在要按照市场部门的意见稍作修改，譬如：将更改某一处设计，
然后推出一个新产品；

 

让我们来了解builder 模式的结构：如图

 

我们可以看到其参与者包括：
Builder(CarBuilder)
：为创建Product对象的各部分指定抽象接口；（CreateWindow(),CreateEnginee(),CreateWheel()）
ConcerteBuilder(StnCarBuilder)
：实现Builder的接口以创建和装配产品的各部分； （CreateWindow(),CreateEnginee(),CreateWheel()）
：定义并明确创建的表示 
：提供一个检索产品的接口 （GetStnCar()）

Director(Director)
：构造一个使用Builder接口的对象
Product(StnCar)
：表示被构造的复杂对象
：包含定义组成产品的类，包括将这些部件装配成最终产品的接口

 

接下来让我们先实现产品对象的定义：我们定义一个汽车父类：Car（这不是必需的)zz作为实现产品的接口，
一个子类StnCar来实现真正的产品;

class Car{
Car(){}
void addWindow(Windows _window){}
void addWheel(Wheel _wheel){}
void addEnginee(Enginee _enginee){}
void Runs(){}
}

class StnCar extends Car{
void addWindow(Windows _window){}
void addWheel(Wheel _wheel){}
void addEnginee(Enginee _enginee){} 
StnCar(){}
void Runs(){System.out.println("stncar is ok");}
}

接下来定义产品的各聚合体部件，我们定义桑塔纳汽车的部件如下：

class Windows{
Windows(){}
}

class Wheel{
Wheel(){}
}

class Enginee{
Enginee(){}
}

接下来让我们定义Builder和它的实现Builder既：StnCarBuilder。由他们来负责组合我们所需要的产品。

public class Testaaa
{
 

class   Builder{
       void CreateWindow(){}
       void CreateEnginee(){}
       void CreateWheel(){}
       void CreateStaCar(){}
StnCar GetStnCar(){return null;}
}

class StnCarBuilder extends Builder{
       private StnCar  _stncar;   
      void  StnCarBuilder()  {_stncar=null;}
      void  CreateWindow()   {Windows _window=new Windows();
                        _stncar.addWindow(_window);}
      void  CreateEnginee()  {Enginee _enginee=new Enginee();
                        _stncar.addEnginee(_enginee); }
      void  CreateWheel()    {Wheel _wheel=new Wheel();
                        _stncar.addWheel(_wheel);}
       void CreateStaCar()   {_stncar=new StnCar();}
StnCar GetStnCar()      {return _stncar;}
}

我们现在来定义使用Builder接口的指导者Director:
class Director{

Car CreateProduct(Builder builder)
{builder.CreateStaCar();
 builder.CreateWindow();
 builder.CreateEnginee();
 builder.CreateWheel();
 
 
return builder.GetStnCar();
}

}

最后我们测试我们的产品是否生产完毕。注意使用了car类。我们可以不再指定具体的产品，实现了abstract
factory 的某些优点。
public static void main(String[] args)
{   Director _d=new Director();
 Car _car=null;
 StnCarBuilder _stncarbuilder=new StnCarBuilder();
 _car=_d.CreateProduct(_stncarbuilder);
 _car.Runs();
 
}

}