建造者模式Builder Pattern

模式的定义与特点

建造者（Builder）模式的定义：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

该模式的主要优点如下：
各个具体的建造者相互独立，有利于系统的扩展。
客户端不必知道产品内部组成的细节，便于控制细节风险。

其缺点如下：
产品的组成部分必须相同，这限制了其使用范围。
如果产品的内部变化复杂，该模式会增加很多的建造者类。

建造者（Builder）模式和工厂模式的关注点不同：
建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程，但两者可以结合使用。

何时使用：一些基本部件不会变，而其组合经常变化的时候。
如何解决：将变与不变分离开。
关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

实现

食品外卖建造模型如下

公共元素组成

//元素
public interface Item { 
   public String name();
   public Packing packing();//打包
   public float price();    
}

public interface Packing {
   public String pack();
}

包装类实现子类：袋装，瓶装

Wrapper.java
public class Wrapper implements Packing {
 
   @Override
   public String pack() {
      return "Wrapper";
   }
}
Bottle.java
public class Bottle implements Packing {
 
   @Override
   public String pack() {
      return "Bottle";
   }

食品子类：使用包装袋的食品

VegBurger.java
public class VegBurger  implements Item {
 
   @Override
   public Packing packing() {
      return new Wrapper();
   }
   @Override
   public float price() {
      return 25.0f;
   }
 
   @Override
   public String name() {
      return "Veg Burger";
   }
}
ChickenBurger.java
public class ChickenBurger  implements Item {
 
   @Override
   public Packing packing() {
      return new Wrapper();
   }
 
   @Override
   public float price() {
      return 50.5f;
   }
 
   @Override
   public String name() {
      return "Chicken Burger";
   }
}

食品子类：使用瓶装的食品

public class Coke implements Item {
 
  @Override
    public Packing packing() {
       return new Bottle();
    }
 
   @Override
   public float price() {
      return 30.0f;
   }
 
   @Override
   public String name() {
      return "Coke";
   }
}
Pepsi.java
public class Pepsi implements Item {
 
 @Override
    public Packing packing() {
       return new Bottle();
    }
 
   @Override
   public float price() {
      return 35.0f;
   }
 
   @Override
   public String name() {
      return "Pepsi";
   }
}

食品建造者:提供了计算价格，方案A,B,C三种方案

public class FoodBuilder{
   private List<Item>  result= new ArrayList<Item>();    
 
   public float getCost(){
      float cost = 0.0f;
      for (Item item : result) {
         cost += item.price();
      }        
      return cost;
   }
 
   public void showItems(){
      for (Item item : result) {
         System.out.print("Item : "+item.name());
         System.out.print(", Packing : "+item.packing().pack());
         System.out.println(", Price : "+item.price());
      }        
   }    

//方案1
 public Meal prepareVegMealA (){

      result.addItem(new VegBurger());
      result.addItem(new Coke());
      return result;
   }   
 
 //方案2
   public Meal prepareVegMealB(){
      result.addItem(new ChickenBurger());
      return result;
   }

 //方案3
   public Meal prepareVegMealC(){
	 result.addItem(new VegBurger());
      result.addItem(new Coke());
      result.addItem(new ChickenBurger());
      return result;
   }

}

总结

建造者还可以单独把一些公共方法和参数提出来，提供一个接口，这样其他方案继承该接口实现各自的方案。但随着产品的多样化和复杂化，那么建造者的实现方类也必然变的繁杂和更加复杂。但好处是，使用过程中，我们只关注建造者的使用方法，具体如何复杂和产品多样都不是使用者关心的，这样构建过程将显的简洁而明了。

//一行代码即可创建预期的结果
 FoodBuilder.prepareVegMealA();
 FoodBuilder.prepareVegMealC();

参考资料

http://c.biancheng.net/view/1354.html
https://www.runoob.com/design-pattern/builder-pattern.html