设计模式-创建型-抽象工厂模式

　　前一章节，我们介绍了简单工厂模式以及工厂方法模式，但是这两种模式都存在一定的局限性，只能生产某一类型下的某一种产品，如果需求变更，同类型下出现了不同的产品，比如芝士披萨不仅有口味上的不同，同时存在外观上的不同。这种时候，工厂模式显然不再满足要求，该怎么办呢？于是我们想到DIP原则，它不正是为了解决这种情况而存在的吗？接下来我们来介绍下抽象工厂模式：

　　1、抽象工厂模式定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类。

　　2、抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。

　　3、从设计层面来说，抽象工厂模式就是对简单工厂模式的改进（即进一步抽象化）

　　4、将工厂抽象成两层，抽象工厂和具体的实现工厂。

还是拿pizza订购举例,我们定义一个抽象工厂AbsFactory，由子类工厂实现该抽象工厂；订购披萨OrderPizza依赖抽象，不依赖具体的实现。

 　　

internal class Program
{
    private static void Main(string[] args)
    {
        new OrderPizza(new BJFactory());
    }
}

internal class OrderPizza
{
    private AbsFactory factory;

    public OrderPizza(AbsFactory factory)
    {
        setFactory(factory);
        Order();
    }

    private void setFactory(AbsFactory factory)
    {
        this.factory = factory;
    }

    private void Order()
    {
        Pizza pizza = null;
        string orderType = "";
        do
        {
            Console.Write("请输入订购类型：");
            orderType = Console.ReadLine();
            pizza = this.factory.createPizza(orderType);
            if (pizza == null)
            {
                Console.WriteLine("订购失败");
                break;
            }
            //开始制作
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }
}

internal interface AbsFactory
{
    Pizza createPizza(string orderType);
}

internal class BJFactory : AbsFactory
{
    public Pizza createPizza(string orderType)
    {
        Pizza pizza = null;
        if (orderType == "cheese")
        {
            pizza = new BJCheesePizza();
            pizza.setName("北京芝士披萨");
        }
        else if (orderType == "greek")
        {
            pizza = new BJGreekPizza();
            pizza.setName("北京希腊披萨");
        }
        return pizza;
    }
}

internal class LDFactory : AbsFactory
{
    public Pizza createPizza(string orderType)
    {
        Pizza pizza = null;
        if (orderType == "cheese")
        {
            pizza = new LDCheesePizza();
            pizza.setName("伦敦芝士披萨");
        }
        else if (orderType == "greek")
        {
            pizza = new LDGreekPizza();
            pizza.setName("伦敦希腊披萨");
        }
        return pizza;
    }
}

internal abstract class Pizza
{
    private string name;

    public abstract void prepare();

    public void bake()
    {
        Console.WriteLine($"{this.name} 烘培");
    }

    public void cut()
    {
        Console.WriteLine($"{this.name} 修剪");
    }

    public void box()
    {
        Console.WriteLine($"{this.name} 打包");
    }

    public void setName(string name)
    {
        this.name = name;
    }
}

internal class BJCheesePizza : Pizza
{
    public override void prepare()
    {
        Console.WriteLine("北京的芝士披萨准备中");
    }
}

internal class BJGreekPizza : Pizza
{
    public override void prepare()
    {
        Console.WriteLine("北京的希腊披萨准备中");
    }
}

internal class LDCheesePizza : Pizza
{
    public override void prepare()
    {
        Console.WriteLine("伦敦的芝士披萨准备中");
    }
}

internal class LDGreekPizza : Pizza
{
    public override void prepare()
    {
        Console.WriteLine("伦敦的希腊披萨准备中");
    }
}

读过一些博主的博文以及评论，有一些理解还是蛮到位的：

　　1、抽象工厂比工厂方法复杂的多，它们的目的不同。工厂方法意在延迟加载，而抽象方法意在高内聚低耦合。

　　2、工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂可以创建多个。

参考：https://www.runoob.com/design-pattern/abstract-factory-pattern.html