【设计模式】抽象工厂模式

抽象工厂模式是属于创建型模式。抽象工厂提供一个创建一系列相关或相互依赖的对象的接口，而无需指定它们具体的类。这样的描述我们会觉得和工厂模式比较像，那么工厂模式和抽象工厂模式的区别是什么呢？

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

工厂方法的鸽子店只能生产鸽子一种产品；而抽象工厂的鸽子店可以生产大鸽子，乳鸽，鸽子蛋等多种产品。

C#代码：

using System;

namespace ConsoleApp
{

    public interface IBird
    {
        string Talk();
    }

    public abstract class BirdAdult : IBird
    {
        protected string size = "adult";
        public abstract string Talk();
    }

    public abstract class BirdBaby : IBird
    {
        protected string size = "baby";
        public abstract string Talk();
    }

    public abstract class BirdEgg : IBird
    {
        protected string size = "egg";
        public abstract string Talk();
    }


    public class DoveAdult : BirdAdult
    {
        public override string Talk()
        {
            return string.Format("I am a {0} dove", size);
        }
    }

    public class DoveBaby : BirdBaby
    {
        public override string Talk()
        {
            return string.Format("I am a {0} dove", size);
        }
    }

    public class DoveEgg : BirdEgg
    {
        public override string Talk()
        {
            return string.Format("I am a {0} dove", size);
        }
    }

    public class EagleAdult : BirdAdult
    {

        public override string Talk()
        {
            return string.Format("I am a {0} eagle", size);
        }
    }

    public class EagleBaby : BirdBaby
    {
        public override string Talk()
        {
            return string.Format("I am a {0} eagle", size);
        }
    }

    public class EagleEgg : BirdBaby
    {
        public override string Talk()
        {
            return string.Format("I am a {0} eagle", size);
        }
    }


    public interface IBirdFactory
    {
        IBird CreateAdult();
        IBird CreateBaby();

        IBird CreateEgg();
    }

    /// <summary>
    /// 抽象工厂： 鸽子工厂里面不但可以生产大鸽子，小鸽子，还可以生产鸽子蛋，以后还可以生产鸽子汤等其它产品
    /// </summary>
    public class DoveFactory : IBirdFactory
    {
        public IBird CreateAdult()
        {
            return new DoveAdult();
        }

        public IBird CreateBaby()
        {
            return new DoveBaby();
        }
        public IBird CreateEgg()
        {
            return new DoveEgg();
        }
    }

    public class EagleFactory : IBirdFactory
    {
        public IBird CreateAdult()
        {
            return new EagleAdult();
        }

        public IBird CreateBaby()
        {
            return new EagleBaby();
        }

        public IBird CreateEgg()
        {
            return new EagleEgg();
        }
    }


    public class Program
    {
        static void Main(string[] args)
        {
            string talkContent;

            DoveFactory doveFactory = new DoveFactory();

            talkContent = doveFactory.CreateAdult().Talk();
            Console.WriteLine(talkContent);

            talkContent = doveFactory.CreateBaby().Talk();
            Console.WriteLine(talkContent);

            talkContent = doveFactory.CreateEgg().Talk();
            Console.WriteLine(talkContent);

            //--------------------------------------------
            EagleFactory eagleFactory = new EagleFactory();

            talkContent = eagleFactory.CreateAdult().Talk();
            Console.WriteLine(talkContent);

            talkContent = eagleFactory.CreateBaby().Talk();
            Console.WriteLine(talkContent);

            talkContent = doveFactory.CreateEgg().Talk();
            Console.WriteLine(talkContent);





            Console.Read();
        }
    }
}