Builder(生成器)模式属于对象创建型模式;

㈠意图:

  将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示.

  --GOF设计模式.

㈡理解:

  同样的构建过程:意即在构建复杂对象的时候,所创建这个复杂对象的过程是不变的;

  比如:准备一个美味的菜肴;一般都需要经过以下三个过程;

  ①处理原材料(如果是青菜就需要处理一些烂叶子;荤菜就要杀生了.)

  ②加工处理(或炒,或煮,或蒸)

  ③加调料,完工.

  与它的表示相分离:意思是指将构建的过程从具体复杂对象中抽取出来;不和每个具体地复杂对象相绑定.

   例如:做青菜时,只包含这三个步骤的具体实现;而并不包括;这三个步骤的先后顺序.

㈢UML图：

　

㈣参与者:

  ①Builder

   -- 指定了创建一个复杂对象中各个部件(部分)的抽象接口

  ②ConcreteBuilder

   -- 实现了Builder接口中构造各个部件的具体方法;

   -- 定义并明确它所创建的具体的对象是什么(Product)

   -- 提供一个获取最终生成复杂对象的接口方法(getResult).

  ③Direct(导向器)

    -- 构造一个使用Builder接口的对象;并组合这个对象的生成具体部件的方法;并最终通知Builder构建完最终的复杂对象.

  ④Product

    -- 最终的复杂对象.

㈤协作关系:

㈥代码表示:

 

 
  
  1. /** 
  2.  * 产品 
  3.  */ 
  4. package com.skywares.designpattern.builder; 
  5.  
  6. /** 
  7.  * @author hubert 
  8.  * 
  9.  */ 
  10. public class FishFood { 
  11.     public FishFood() 
  12.     { 
  13.         System.out.println("fish food !!"); 
  14.     } 
  15. } 
 
  
 
 
  
 
  
  1. /** 
  2.  * Builder模式中的Builder角色; 
  3.  */ 
  4. package com.skywares.designpattern.builder; 
  5.  
  6. /** 
  7.  * @author hubert 
  8.  * 
  9.  */ 
  10. public interface FoodBuilder 
  11. { 
  12.     void prepareFood(); 
  13.     void handleFood(); 
  14.     void postFood(); 
  15.     FishFood getFood(); 
  16. } 
 
  
 
 
  
 
  
  1. /** 
  2.  * Builder模式中的具体Builder角色 
  3.  */ 
  4. package com.skywares.designpattern.builder; 
  5.  
  6. /** 
  7.  * @author hubert 
  8.  * 
  9.  */ 
  10. public class FishFoodBuilder implements FoodBuilder { 
  11.  
  12. //  private FishFood fishFood; 
  13.      
  14.     @Override 
  15.     public void prepareFood() { 
  16.         System.out.println(" 太可怜了!!请保护动物 "); 
  17.     } 
  18.  
  19.     @Override 
  20.     public void handleFood() { 
  21.         System.out.println(" 清蒸吗? "); 
  22.     } 
  23.  
  24.     @Override 
  25.     public void postFood() { 
  26.         System.out.println(" 伤口上撒盐!? "); 
  27.     } 
  28.      
  29.     public FishFood getFood() 
  30.     { 
  31.         return new FishFood(); 
  32.     } 
  33.  
  34. } 
 
  
 
 
  
 
  
  1. /** 
  2.  * Director角色 
  3.  */ 
  4. package com.skywares.designpattern.builder; 
  5.  
  6. /** 
  7.  * @author hubert 
  8.  * 
  9.  */ 
  10. public class FoodDirector { 
  11.      
  12.     private FoodBuilder foodBuilder; 
  13.      
  14.     public FoodDirector(FoodBuilder foodBuilder) 
  15.     { 
  16.         this.foodBuilder = foodBuilder; 
  17.     } 
  18.      
  19.     public FishFood constructFood() 
  20.     { 
  21.         foodBuilder.prepareFood(); 
  22.         foodBuilder.handleFood(); 
  23.         foodBuilder.postFood(); 
  24.         return foodBuilder.getFood(); 
  25.     } 
  26.  
  27. } 
 
  
 
 
  
 
  
  1. /** 
  2.  * 测试类 
  3.  */ 
  4. package com.skywares.designpattern.builder; 
  5.  
  6. /** 
  7.  * @author hubert 
  8.  * 
  9.  */ 
  10. public class Client { 
  11.  
  12.     /** 
  13.      * @param args 
  14.      */ 
  15.     public static void main(String[] args) { 
  16.         FoodBuilder foodBuiler = new FishFoodBuilder(); 
  17.         FoodDirector foodDirector = new FoodDirector(foodBuiler); 
  18.         foodDirector.constructFood(); 
  19.     } 
  20.  
  21. } 
 
  
 后记:
 
  
  Builder模式和Template Method模式有点像;主要表现在创建对象或者方法处理的步骤的部分.
 
  
  但是:Template method属于类行为模式;它主要是封装一些相同的类行为,将一些不确定的类行为方式延迟到子类进行实现;
 
  
  而Builder模式属性对象创建模式;它的主要作用是解决如何创建一个复杂对象的问题;并让这个复杂对象创建的过程与其对应的每个部件的创建过程进行解耦.
 
  
  给出的例子有点不恰当.如果是组装一部汽车什么的可能会更合适一点.