设计模式——建造者模式

介绍

这种类型的设计模式属于创建型模式。

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
主要解决：主要解决在软件系统中，有时候面临着”一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
适用场景：一些基本部件不会变，而其组合经常变化的时候。
例如：去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的”套餐”。

实现

图解

建造者模式

interface Item{
   public String name();
   public float price();    
}
class Burger implements Item{

    @Override
    public String name() {
        return "Burger";
    }
    @Override
    public float price() {
        return 15.0f;
    }
}
class ColdDrink implements Item{

    @Override
    public String name() {
        return "ColdDrink";
    }
    @Override
    public float price() {
        return 8.0f;
    }
}
class Chips implements Item{

    @Override
    public String name() {
        return "Chips";
    }
    @Override
    public float price() {
        return 10.0f;
    }
}
class Meal{
    List<Item> items = new ArrayList<Item>();
    public void addItem(Item item){
          items.add(item);
    }
    public float getCost(){
      float cost = 0.0f;
      for (Item item : items) {
         cost += item.price();
      }        
      return cost;
    }
   public void showItems(){
      for (Item item : items) {
         System.out.print("Item : "+item.name());
         System.out.println(", Price : "+item.price());
      }        
   }    
}
abstract class Builder{
    public abstract Meal getMeal(); 
    public abstract Meal setMeal(List<Item> itemList); 
} 
class MealBuilder extends Builder{
    Meal meal = new Meal();
    @Override
    public Meal getMeal() {
        return meal;
    }
    @Override
    public Meal setMeal(List<Item> itemList) {
        meal.items.clear();
        meal.items.addAll(itemList);
        return meal;
    }
}
class Director {  
    private Builder mealBuilder = new MealBuilder();  
    public Meal getMealA(){  
        List<Item> itemList = new ArrayList<Item>();
        itemList.add(new Burger());
        itemList.add(new Chips());
        mealBuilder.setMeal(itemList);
        return mealBuilder.getMeal();
    }  
    public Meal getMealB(){
        List<Item> itemList = new ArrayList<Item>();
        itemList.add(new Burger());
        itemList.add(new ColdDrink());
        mealBuilder.setMeal(itemList);
        return mealBuilder.getMeal();
    }  
}  
public class Client {
    public static void main(String[] args) {
        Director director = new Director();
        System.out.println("MealA...");
        Meal mealA = director.getMealA();
        mealA.showItems();
        System.out.println("MealB...");
        Meal mealB = director.getMealB();
        mealB.showItems();
    }
}

非建造者模式

interface Item{
   public String name();
   public float price();    
}
class Burger implements Item{
    @Override
    public String name() {
        return "Burger";
    }
    @Override
    public float price() {
        return 15.0f;
    }
}
class ColdDrink implements Item{
    @Override
    public String name() {
        return "ColdDrink";
    }
    @Override
    public float price() {
        return 8.0f;
    }
}
class Chips implements Item{
    @Override
    public String name() {
        return "Chips";
    }
    @Override
    public float price() {
        return 10.0f;
    }
}
class Meal{
    List<Item> items = new ArrayList<Item>();
    public void addItem(Item item){
          items.add(item);
    }
    public float getCost(){
      float cost = 0.0f;
      for (Item item : items) {
         cost += item.price();
      }        
      return cost;
    }
   public void showItems(){
      for (Item item : items) {
         System.out.print("Item : "+item.name());
         System.out.println(", Price : "+item.price());
      }        
   }    
}
public class Client {
    // 不使用建造者模式,创建和表示在一块,没有分离
    public static void main(String[] args) {
        System.out.println("MealA...");
        Meal mealA = new Meal();
        mealA.addItem(new Burger());
        mealA.addItem(new Chips());
        mealA.showItems();
        System.out.println("MealB...");
        Meal mealB = new Meal();
        mealA.addItem(new Burger());
        mealA.addItem(new ColdDrink());
        mealB.showItems();
    }
}

总结

四个要素
产品类：一般是一个较为复杂的对象，也就是说创建对象的过程比较复杂，一般会有比较多的代码量。在本类图中，产品类是一个具体的类，而非抽象类。实际编程中，产品类可以是由一个抽象类与它的不同实现组成，也可以是由多个抽象类与他们的实现组成。
抽象建造者：引入抽象建造者的目的，是为了将建造的具体过程交与它的子类来实现。这样更容易扩展。一般至少会有两个抽象方法，一个用来建造产品，一个是用来返回产品。
建造者：实现抽象类的所有未实现的方法，具体来说一般是两项任务：组建产品；返回组建好的产品。
导演类：负责调用适当的建造者来组建产品，导演类一般不与产品类发生依赖关系，与导演类直接交互的是建造者类。一般来说，导演类被用来封装程序中易变的部分。

优点
使得建造代码与表示代码分离，由于建造者隐藏了该产品是如何组装的，所以若需要改变一个产品的内部表示，只需要再定义一个具体的建造者就可以了。
缺点
如内部变化复杂，会有很多的建造类。