设计模式之建造者模式

本文参考：

https://www.jianshu.com/p/b19eb442f14f

https://www.cnblogs.com/jenkinschan/p/6426694.html

一、什么是建造者模式？

建造者模式可以用造房子来举个例子，不管是别墅，还是平房或者是高楼大厦，都少不了设计整体结构、清理地基、浇筑地梁、砌筑房子基本结构等步骤。

建造者模式的定义：将一个复杂对象的构建（可以将“构建”理解为造房子的过程）与它的表示（将“表示”理解为造出来的别墅、造平房、造高楼）分离，使得同样的构建过程可以创建不同的表示。

二、结构类图　

三、应用实例

假设现在有一个快餐店，其中销量最好的一款套餐就是一个汉堡和一杯饮料。而汉堡有素食汉堡（veg Burger）和鸡肉汉堡（Chicken Burger）可供选择、饮料有可口可乐（coke）和百事可乐（pepsi）可以选择。所以该示例的UML为：

 

下面开始展示代码：
首先创建一个食物条目和食物包装的接口：

//食物条目
public interface Item {
   public String name();
   public Packing packing();
   public float price();    
}

//标识包装 接口
public interface Packing {
   public String pack();
}

然后是实现Packing的实现类

//用于装汉堡
public class Wrapper implements Packing {
 
   @Override
   public String pack() {
      return "Wrapper";
   }
}

//用于装饮料
public class Bottle implements Packing {
 
   @Override
   public String pack() {
      return "Bottle";
   }
}

实现item接口的抽象类

//抽象类 汉堡
public abstract class Burger implements Item {
 
   @Override
   public Packing packing() {
      return new Wrapper();
   }
 
   @Override
   public abstract float price();
}

//抽象类 饮料
public abstract class ColdDrink implements Item {
 
    @Override
    public Packing packing() {
       return new Bottle();
    }
 
    @Override
    public abstract float price();
}

实体类：

// 素菜汉堡
public class VegBurger extends Burger {
 
   @Override
   public float price() {
      return 25.0f;
   }
 
   @Override
   public String name() {
      return "Veg Burger";
   }
}

//鸡肉汉堡
public class ChickenBurger extends Burger {
 
   @Override
   public float price() {
      return 50.5f;
   }
 
   @Override
   public String name() {
      return "Chicken Burger";
   }
}

//可口可乐实体类
public class Coke extends ColdDrink {
 
   @Override
   public float price() {
      return 30.0f;
   }
 
   @Override
   public String name() {
      return "Coke";
   }
}

//百世可乐实体类：
public class Pepsi extends ColdDrink {
 
   @Override
   public float price() {
      return 35.0f;
   }
 
   @Override
   public String name() {
      return "Pepsi";
   }
}

创建一个Meal类，带有上面定义的Item对象

public class Meal {
   private 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.print(", Packing : "+item.packing().pack());
         System.out.println(", Price : "+item.price());
      }        
   }    
}

再创建一个MealBuilder负责创建Meal

public class MealBuilder {
 
    //套餐1 素汉堡
   public Meal prepareVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new VegBurger());
      meal.addItem(new Coke());
      return meal;
   }   
 
   //套餐2 鸡肉汉堡
   public Meal prepareNonVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new ChickenBurger());
      meal.addItem(new Pepsi());
      return meal;
   }
}

测试类：

public class BuilderPatternDemo {
   public static void main(String[] args) {
      MealBuilder mealBuilder = new MealBuilder();
 
      Meal vegMeal = mealBuilder.prepareVegMeal();
      System.out.println("Veg Meal");
      vegMeal.showItems();
      System.out.println("Total Cost: " + vegMeal.getCost());
 
      Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
      System.out.println("\n\nNon-Veg Meal");
      nonVegMeal.showItems();
      System.out.println("Total Cost: " + nonVegMeal.getCost());
   }
}

输出结果：

Veg Meal
Item : Veg Burger, Packing : Wrapper, Price : 25.0
Item : Coke, Packing : Bottle, Price : 30.0
Total Cost: 55.0

Non-Veg Meal
Item : Chicken Burger, Packing : Wrapper, Price : 50.5
Item : Pepsi, Packing : Bottle, Price : 35.0
Total Cost: 85.5

四、优缺点　　

1、优点

　　（1）、产品的建造和表示分离，实现了解耦。

　　（2）、隐藏了产品的建造细节，用户只需关心产品的表示，而不需要了解是如何创建产品的。

　　（3）、体现了开闭原则，如上代码所示，用户选择不同的套餐，都是共用一个流程，无需再开辟一个流程。

2、缺点

　　（1）、当建造者过多时，会产生很多类，难以维护。

五、什么时候使用？

　　建造者模式的使用场合是当创建复杂对象时，把创建对象成员和装配方法分离出来，放在建造者类中去实现，用户使用该复杂对象时，不用理会它的创建和装配过程，只关心它的表示形式。其实完全理解这个模式还是要一番思考的，难以搞懂的是指挥者似乎没什么存在的必要，在代码里也没体现它的作用，我们也可以把指挥者的方法放在建造者里面，但为什么没有这样做呢？我想这可能是考虑到单一责任原则，建造者只负责创建对象的各个部分，至于各个部分创建的顺序、装配方法它就不管了。还有就是当顺序要改变时，建造者可以不用改动，改动指挥者就好了，指挥者只有一个，建造者有很多，要改建造者就麻烦了。