java设计模式之建造者模式

约定不等于承诺〃 2022-11-20 04:51 178阅读 0赞

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

一个Builder类会一步一步构造最终的对象。该Builder类是独立于其他对象的。

**模式介绍：**

**意图：**将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

**主要解决：**主要解决在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

**何时使用：**一些基本部件不会变，而其组合经常变化的时候。

**关键代码：**建造者：创建和提供实例，导演：管理建造出来的实例和依赖关系。

**应用实例：**

*  去肯德基，汉堡、可乐、薯条、炸鸡等是不变的，而其组合是经常变化的，生成所谓的“套餐”。
 *  java中的StringBuilder

**优点：**

*  建造者独立，易扩展。
 *  便于控制细节风险。

**缺点：**

*  产品必须有共同点，范围有限制。
 *  如内部变化复杂，会有很多建造类。

**使用场景：**

*  需要生成的对象具有复杂的内部结构。
 *  需要生成的对象内部本身相互依赖。

**注意事项：**与工厂模式的区别是：建造者模式更加关注与零部件装配的顺序。

**实现：**

假设一个快餐店的商业案例，其中一个典型的套餐可以是一个汉堡(Burger)和一杯冷饮(Cold drink)。汉堡（Burger）可以是素食汉堡(Veg Burger)或鸡肉汉堡(Chicken Burger)，它们是包在纸盒中。冷饮(Cold drink)可以是可口可乐(coke)或者是(pepsi)，它们是装载瓶子中。

我们将建造一个表示食物条目（比如汉堡和冷饮）的item接口和实现item接口的实体类，以及一个表示食物包装的Packing接口和实现Packing接口的实体类，汉堡是包在纸盒中，冷饮是装在瓶子中。

然后我们将创建要给Meal类，带有item的ArrayList和一个通过结合item来创建不同类型的Meal对象的MealBuilder。BuilderPatternDemo类使用MealBuilder来创建一个Meal。

**食物条目接口：**

//Item.java
    public interface Item{
        public String name();
        public Packing packing();
        public float price();
    }

**食物包装接口：**

//Packing.java
    public interface Packing{
        public String pack();
    }

**实现Packing接口的实体类：**

//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";
        }
    }

** 实现Item接口的抽象类，该类提供了默认的功能：**

//Burger.java
    public abstract class Burger implements Item{
        @Override
        public Packing packing(){
            return new Wrapper();
        }
        @Override
        public abstract float price();
    }

//ColdDrink.java
    public abstract class ColdDrink implements Item{
        @Override
        public Packing packing(){
            return new Bottle();
        }
        @Override
        public abstract float price();
    }

** 扩展了Burger的实体类：**

//VegBurger.java
    public class VegBurger extends Burger{
        @Override
        public float price(){
            return 25.0f;
        }
        @Override
        public String name(){
            return "Veg Burger";
        }
    }

//ChickenBurger.java
    public class ChickenBurger extends Burger{
        @Override
        public float price(){
            return 50.5f;
        }
        @Override
        public String name(){
            return "Chick Burger";
        }
    }

**扩展了ColdDrink的实体类：**

//Coke.java
    public class Coke extends ColdDrink{
        @Override
        public float price(){
            return 30.0f;
        }
        @Override
        public String name(){
            return "Coke";
        }
    }

//Pepsi.java
    public class Pepsi extends ColdDrink{
        @Override
        public float price(){
            return 35.0f;
        }
        @Override
        pbulic String name(){
            return "Pepsi";
        }
    }

**创建一个Meal类，带有上面的Item对象：**

//Meal.java
    import java.util.ArrayList;
    import java.util.List;
    
    public class Meal{
        private List<Item> items = new ArrayList<Item>();
        public void addItem(Item item){
            items.add(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类，实际的builder类负责创建Meal对象：**

//MealBuilder.java
    public class MealBuilder{
        public Meal prepareVegMeal(){
            Meal meal = new Meal();
            meal.addItem(new VegBurger());
            meal.addItem(new Coke());
            return meal;
        }
        public Meal prepareMonVegMeal(){
            Meal meal = new Meal();
            meal.addItem(new ChickenBurger()):
            meal.addItem(new Pepsi());
            return meal;
        }
    }

** BuilderPatternDemo使用MealBuilder来演示建造者模式：**

//BuilderPatternDemo.java
    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