设计模式-----建造者模式

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

2. 好处
   保证了流程不会变化

3. 建造者模式主要包括以下几个角色

   • Builder（建造者）：给出一个抽象接口，以规范产品对象的各个组成部分的构建。该接口要规定要实现复杂对象的哪些部分的创建，并不涉及具体的创建。
   • ConcreteBuilder（具体建造者）：实现Builder接口，根据不同的商业逻辑，具体化各部分的创建，在建造完成后提供产品的实例。
   • Director（负责指挥者）：调用具体的建造者来复杂对象的各部分，在知道中不涉及具体的产品信息，只负责保证对象各部分完整创建或者按照某种顺序创建。
   • Product（具体产品）：要创建的复杂对象。

4. 代码示例角色对应关系为

   • Builder——> IFood
   • ConcreteBuilder——> Cooker + IFood具体实例
   • Director——> BuilderPattern
   • Product——> Dinner

5. 以饭店厨师做餐为例

   以饭店出参过程为例：用户下单后，老板（指挥者）会要求厨师做餐（建造者）给用户提供晚餐（具体产品）

   1. 首先给出一个抽象接口，以规范产品对象的各个组成部分的构建。

       // 食物组成为    名称  包装  价格
       public interface IFood {
        public String name();
        public String packing();
        public Float price();
      }

   2. 实现Builder接口，根据不同的商业逻辑，具体化各部分的创建

      /**
       *  晚餐组成部分  绝味薯条
       */
      public class Chips implements IFood {
          @Override
          public String name() {
              return "绝味薯条";
          }
          @Override
          public String packing() {
              return "袋装";
          }
          @Override
          public Float price() {
              return 6.6f;
          }
      }
      /**
       *  晚餐组成部分  百事可乐
       */
      public class Pepsi implements IFood {
          @Override
          public String name() {
              return "百事可乐";
          }
          @Override
          public String packing() {
              return "瓶装";
          }
          @Override
          public Float price() {
              return 8f;
          }
      }
      /**
       *  晚餐组成部分  鸡肉汉堡
       */
      public class ChickenBurger implements IFood {
          @Override
          public String name() {
              return "鸡肉汉堡";
          }
          @Override
          public String packing() {
              return "袋装";
          }
          @Override
          public Float price() {
              return 16f;
          }
      }

   3. 要创建的复杂对象，具体的对象

      public class Dinner {
       private List<IFood> list = new ArrayList<>();
       public void addFood(IFood food){
           list.add(food);
       }
       public float getTotalPrice(){
           float cost = 0.0f;
           for (IFood food : list) {
               cost += food.price();
           }
           return cost;
       }
       public void showFood(){
           System.out.println("晚餐菜单：");
           for (IFood food: list){
               System.out.printf("    "+food.name());
               System.out.printf("  "+food.packing());
               System.out.printf("  ￥"+food.price());
               System.out.println();
           }
       }
      }

   4. 调用具体的建造者来复杂对象的各部分，老板指挥厨师做餐

      public class BuilderPattern {
       public static void main(String[] args) {
           Cooker cooker  = new Cooker();
           Dinner dinner = cooker.doDinner();
           dinner.showFood();
           System.out.println("总金额为：￥"+dinner.getTotalPrice());
       }
      }
      public class Cooker {
       public Dinner doDinner(){
           Dinner dinner = new Dinner();
           dinner.addFood(new ChickenBurger());
           dinner.addFood(new Chips());
           dinner.addFood(new Pepsi());
           return  dinner;
       }
      }

   5. 测试结果

      晚餐菜单：

      鸡肉汉堡 袋装 ￥16.0

      绝味薯条 袋装 ￥6.6

      百事可乐 瓶装 ￥8.0

      总金额为：￥30.6