java设计模式之建造者模式

青玄

建造者模式是将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。 [构建与表示分离，同构建不同表示]

    与抽象工厂的区别：在建造者模式里，有个指导者，由指导者来管理建造者，用户是与指导者联系的，指导者联系建造者最后得到产品。即建造模式可以强制实行一种分步骤进行的建造过程。

　　建造模式是将复杂的内部创建封装在内部，对于外部调用的人来说，只需要传入建造者和建造工具，对于内部是如何建造成成品的，调用者无需关心。

如图所示：

需要说明一下几个类的作用：
Client: 相当于用户，它需要什么我们就给他什么，至于怎么实现，这个用户就不用去关心啦
CarModel以及两个实现类BenzModel和BMWModel叫做产品类，这个产品类实现了模板方法模式，也就是有模板方法
CarBuilder以及两个实现类BenzBuilder和BMWBuilder叫做建造者，负责建造Benz和BMW 车模，按照指定的顺序
Director类叫做导演类，负责安排已有模块的顺序，然后告诉Builder开始建造 ;

恩～～ 以下就是程序的具体实现：
首先从模型开始吧！来一个模型的抽象类CarModel.java：

import java.util.*;

public abstract class CarModel
{
  //这个参数是各个基本方法执行的顺序
  private ArrayList<String> sequence = new ArrayList<String>();

  //启动
  protected abstract void start();
  //停止
  protected abstract void stop();
  //喇叭的叫
  protected abstract void alarm();
  //引擎的响
  protected abstract void engineBoom();

  //跑起来
  final public void run()
  {
     //循环一遍，谁在前，就先执行谁
     for(int i=0; i<this.sequence.size(); i++)
     {
        String actionName = this.sequence.get(i);

        if(actionName.equalsIgnoreCase("start"))
        {
           this.start();
        }else if(actionName.equalsIgnoreCase("stop"))
        {
           this.stop();
        }else if(actionName.equalsIgnoreCase("alarm"))
        {
           this.alarm();
        }else if(actionName.equalsIgnoreCase("engine boom"))
        {
           this.engineBoom();
        }
     }
  }
  //把传递过来的值传递到类内
   final public void setSequence(ArrayList<String> sequence)
   {
      this.sequence = sequence;
   }
}

然后就是两个实现类BenzModel与BMWBuilder：

public class BenzModel extends CarModel
{
   protected void alarm()
   {
      System.out.println("奔驰车的喇叭声音是这个样子的...");
   }
   protected void engineBoom()
   {
       System.out.println("奔驰的引擎是这个声音...");
   }
   protected void start()
   {
      System.out.println("奔驰车跑起来啦...");
   }
   protected void stop()
   {
      System.out.println("奔驰车停下来啦...");
   }

}

public class BMWModel extends CarModel
{
   protected void alarm()
   {
      System.out.println("宝马车的喇叭声音是这个样子的...");
   }
   protected void engineBoom()
   {
      System.out.println("宝马车的引擎是这个声音...");
   }
   protected void start()
   {
      System.out.println("宝马车跑起来啦...");
   }
   protected void stop()
   {
      System.out.println("宝马车停下来啦...");
   }

}

然后就是建造者的抽象类来获得模型：

import java.util.ArrayList;

public abstract class CarBuilder
{
   //建造一个模型，要给一个顺序，就是组装顺序
   public abstract void setSequence(ArrayList<String> sequece);
   //设置完毕顺序后，就可以直接拿到这个车辆模型
   public abstract CarModel getCarModel();
}

下面就是两个实现的类BenzBuilder 和 BMWBuilder：

import java.util.ArrayList;

public class BenzBuilder extends CarBuilder
{
   private BenzModel benz = new BenzModel();

   public CarModel getCarModel()
   {
       return this.benz;
   }

   public void setSequence(ArrayList<String> sequece)
   {
      this.benz.setSequence(sequece);
   }

}

import java.util.ArrayList;

public class BenzBuilder extends CarBuilder
{
   private BenzModel benz = new BenzModel();

   public CarModel getCarModel()
   {
       return this.benz;
   }

   public void setSequence(ArrayList<String> sequece)
   {
      this.benz.setSequence(sequece);
   }

}

然后就是Director这个的导演类：

import java.util.ArrayList;

public class Director
{
   private ArrayList<String> sequence = new ArrayList<String>();
   private BenzBuilder benzBuilder = new BenzBuilder();

   private BMWBuilder bmwBuilder = new BMWBuilder();
   /**
    * A类型的奔驰车模型，先start,然后stop,其他什么，一概没有
    */
   public BenzModel getABenzModel()
   {
      //清理，这个得注意
      this.sequence.clear();
      //这只ABenzModel的执行顺序
      this.sequence.add("start");
      this.sequence.add("stop");
      //按照顺序返回一个奔驰车
      this.benzBuilder.setSequence(this.sequence);

      return (BenzModel)this.benzBuilder.getCarModel();
   }
   /**
    * B型号的奔驰车模型，是先发动引擎，然后启动，然后停止，没有喇叭
    */
   public BenzModel getBBenzModel()
   {
       this.sequence.clear();
       this.sequence.add("engine boom");
       this.sequence.add("start");
       this.sequence.add("stop");

       this.benzBuilder.setSequence(this.sequence);
       return (BenzModel)this.benzBuilder.getCarModel();
   }
   /**  
    * C 型号的宝马车是先按下喇叭，然后启动，然后停止
    */
   public BMWModel getCBMWModel()
   {
       this.sequence.clear();

       this.sequence.add("alarm");
       this.sequence.add("start");
       this.sequence.add("stop");

       this.bmwBuilder.setSequence(this.sequence);
       return (BMWModel)this.bmwBuilder.getCarModel();
   }
   /**
    * D类型的宝马只有一个功能，就是跑。启动起来就跑，永远不停止
    */

   public BMWModel getDBMWModel()
   {
        this.sequence.clear();
        this.sequence.add("start");
        this.bmwBuilder.setSequence(this.sequence);
        return (BMWModel)this.benzBuilder.getCarModel();
   }
}
                                     

然后就是用户类：

public class Client
{
        public static void main(String args[])
        {
           Director director = new Director();
           //1w辆A类型的奔驰车
          for(int i=0; i < 10000; i++)
          {
            director.getABenzModel().run();
          }
            //100w辆B类型的奔驰车
           for(int i=0; i < 1000000; i++)
          {
             director.getBBenzModel().run();
          }
       }
}