创建型——建造者模式

推荐文档：

https://www.cnblogs.com/zhili/p/DesignPatternSummery.html

https://www.runoob.com/design-pattern/design-pattern-tutorial.html

什么是建造者模式？#

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

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

相关介绍#

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

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

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

如何解决：将变与不变分离开。

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

应用实例：

1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。

2、JAVA 中的 StringBuilder。

优点：

1、建造者独立，易扩展。

2、便于控制细节风险。

缺点：

1、产品必须有共同点，范围有限制。

2、如内部变化复杂，会有很多的建造类。

使用场景：

1、需要生成的对象具有复杂的内部结构。

2、需要生成的对象内部属性本身相互依赖。

注意事项：

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

相关实现#

我们假设一个快餐店的商业案例，其中，一个典型的套餐可以是一个汉堡（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。

 

namespace Biao.DesignPatterns.CreationalPatterns
{
    /// <summary>
    /// 创建一个表示食物条目的接口
    /// </summary>
    public interface Item
    {
        public string Name();
        public IPacking Packing();
        public float Price();
    }

    /// <summary>
    /// 创建一个表示食物包装的接口
    /// </summary>
    public interface IPacking
    {
        public string Pack();
    }

    /// <summary>
    /// 实现Packing接口的实体类Warpper
    /// </summary>
    public class Warpper : IPacking
    {
        public string Pack()
        {
            return "Warpper";
        }
    }

    /// <summary>
    /// 实现Packing接口的实体类Bottle
    /// </summary>
    public class Bottle : IPacking
    {
        public string Pack()
        {
            return "Bottle";
        }
    }

    /// <summary>
    /// 创建实现Item接口的抽象类Burger，该类提供默认功能
    /// </summary>
    public abstract class Burger : Item
    {
        public abstract string Name();

        public IPacking Packing()
        {
            return new Warpper();
        }

        public abstract float Price();
    }

    /// <summary>
    /// 创建实现Item接口的抽象类ColdDrink，该类提供默认功能
    /// </summary>
    public abstract class ColdDrink : Item
    {
        public abstract string Name();

        public IPacking Packing()
        {
            return new Bottle();
        }

        public abstract float Price();
    }

    /// <summary>
    /// 创建扩展Burger抽象类的实体类VegBurger
    /// </summary>
    public class VegBurger : Burger
    {
        public override string Name()
        {
            return "VegBurger";
        }

        public override float Price()
        {
            return 25.0f;
        }
    }

    /// <summary>
    /// 创建扩展Burger抽象类的实体类ChickenBurger
    /// </summary>
    public class ChickenBurger : Burger
    {
        public override string Name()
        {
            return "ChickenBurger";
        }

        public override float Price()
        {
            return 30.0f;
        }
    }

    /// <summary>
    /// 创建扩展ColdDrink抽象类的实体类Coke
    /// </summary>
    public class Coke : ColdDrink
    {
        public override string Name()
        {
            return "Coke";
        }

        public override float Price()
        {
            return 30.0f;
        }
    }

    /// <summary>
    /// 创建扩展ColdDrink抽象类的实体类Orangejuice
    /// </summary>
    public class Orangejuice : ColdDrink
    {
        public override string Name()
        {
            return "Orangejuice";
        }

        public override float Price()
        {
            return 28.0f;
        }
    }

    /// <summary>
    /// 创建一个 Meal 类，带有上面定义的 Item 对象。
    /// </summary>
    public class Meal
    {
        private List<Item> items = new List<Item>();

        public void AddItem(Item item)
        {
            items.Add(item);
        }

        public float GetCost()
        {
            float cost = 0.0f;
            foreach (Item item in items)
            {
                cost += item.Price();
            }
            return cost;
        }

        public void ShowItems()
        {
            foreach (Item item in items)
            {
                Console.WriteLine("Item:" + item.Name() + ", Packing:" + item.Packing().Pack() + ", Price:" + item.Price());
            }
        }
    }

    /// <summary>
    /// 创建一个 MealBuilder 类，实际的 builder 类负责创建 Meal 对象。
    /// </summary>
    public class MealBuilder
    {
        public Meal PrepareVegMeal()
        {
            Meal meal = new Meal();
            meal.AddItem(new VegBurger());
            meal.AddItem(new Coke());
            return meal;
        }

        public Meal PrepareNonVegMeal()
        {
            Meal meal = new Meal();
            meal.AddItem(new ChickenBurger());
            meal.AddItem(new Orangejuice());
            return meal;
        }
    }
}
 

static void TestBuilderPattern()
{
    Console.WriteLine("---------------测试建造者模式-------------");
    MealBuilder mealBuilder = new MealBuilder();
    Meal vegMeal = mealBuilder.PrepareVegMeal();
    Console.WriteLine("VegMeal");
    vegMeal.ShowItems();
    Console.WriteLine("Total Cost:" + vegMeal.GetCost());

    Meal nonVegMeal = mealBuilder.PrepareNonVegMeal();
    Console.WriteLine("NonVegMeal");
    nonVegMeal.ShowItems();
    Console.WriteLine("Total Cost:" + nonVegMeal.GetCost());
}