设计模式之抽象工厂

上一篇介绍了工厂模式，接下来介绍抽象工厂。

抽象工厂类图来自百度：

这个图看着有点晕，我们换张，来自博客园的：

 工厂方法中，一个工厂只负责实例化一个类，而抽象工厂里一个工厂可以实现化两个（或多个类） 而这两个类是可以分别继承自不同的类的。这是关键。

工厂方法模式针对的是一个产品等级结构，就是子类全继承自一个类；而抽象工厂模式针对的是多个产品等级结构，就是继承自多个父类。

在每一个产品等级结构中（继承自同一个类），功能相关联的产品(由同一个工厂创建)组成的家族，就叫产品簇。

总的来说就是不同的具体工厂生产不同的产品族，

现在我们再来看第一个图：

1. 具体工厂ConcreteCreator1有两个创建方法，分别用于创建ProductA1和ProductB1.

2. 这个ProductA1和ProductB1,构成一个产品族1，ProductA2和ProductB2构成产品族2.

3. 一个具体工厂负责创建一个产品族。

4. 从上得知，a) 这个模式中有多少个产品基类，工厂中，就会有多少个创建方法。b) 有几个产品族，就有几个具体的工厂

举例例子：Mac系列有三款产品：Mac Pro ,Mac Air, Mac Mini

                  iPad也有三款产品： iPad Pro,  iPad Air ,iPad Mini

我们分析一下，就会得出如下的设计：

1. 这里有两个产品等级结构（产品基类）：Mac和iPad

2. 抽象工厂中就会有两个抽象的创建方法：createMac() 和 createIPad(),

3. 有三个产品族:Pro，Air，Mini。

4. 也就会有三个具体的工厂：ProFactory, AirFactory, MiniFactory

5. 抽象工厂中就会有两个抽象的创建方法：createMac() 和 createIPad(),

下面我们来看代码：

 public abstract class Mac
    {
        public abstract void Show();
    }

    public class MacPro : Mac
    {
        public override void Show()
        {
            Console.WriteLine("我是 Mac Pro");
        }
    }

    public class MacAir : Mac
    {
        public override void Show()
        {
            Console.WriteLine("我是 Mac Air");
        }
    }

    public class MacMini : Mac
    {
        public override void Show()
        {
            Console.WriteLine("我是 Mac Mini");
        }
    }

    public abstract class IPad
    {
        public abstract void Show();
    }

    public class IPadPro : IPad
    {
        public override void Show()
        {
            Console.WriteLine("我是 IPad Pro");
        }
    }

    public class IPadAir : IPad
    {
        public override void Show()
        {
            Console.WriteLine("我是 IPad Air");
        }
    }

    public class IPadMini : IPad
    {
        public override void Show()
        {
            Console.WriteLine("我是 IPad Mini");
        }
    }

    public abstract class AbstractFactory
    {
        public abstract Mac CreateMac();
        public abstract IPad CreateIPad();
    }

    /// <summary>
    /// Pro产品族工厂
    /// </summary>
    public class ProFactory : AbstractFactory
    {
        public override IPad CreateIPad()
        {
            return new IPadPro();
        }

        public override Mac CreateMac()
        {
            return new MacPro();
        }
    }

    /// <summary>
    /// Air产品族工厂
    /// </summary>
    public class AirFactory : AbstractFactory
    {
        public override IPad CreateIPad()
        {
            return new IPadAir();
        }

        public override Mac CreateMac()
        {
            return new MacAir();
        }
    }

    /// <summary>
    /// Mini产品族工厂
    /// </summary>
    public class MiniFactory : AbstractFactory
    {
        public override IPad CreateIPad()
        {
            return new IPadMini();
        }

        public override Mac CreateMac()
        {
            return new MacMini();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.OutputEncoding = Encoding.UTF8;

            AbstractFactory profactory = new ProFactory();
            AbstractFactory airfactory = new AirFactory();
            AbstractFactory minifactory = new MiniFactory();

            Mac macPro = profactory.CreateMac();
            Mac macAir = airfactory.CreateMac();
            Mac macMini = minifactory.CreateMac();
            macPro.Show();
            macAir.Show();
            macMini.Show();

            IPad iPadPro = profactory.CreateIPad();
            IPad iPadAir = airfactory.CreateIPad();
            IPad iPadMini = minifactory.CreateIPad();
            iPadPro.Show();
            iPadAir.Show();
            iPadMini.Show();


            Console.ReadKey();
        }
    }

回过头来，我们再来看工厂方法模块与抽象工厂方法模式的区别，就在于，一个工厂由过去只实例化一个产品，到现在实例化两个产品而已。具体工厂的数量仍然与产品子类的个数相关。