《软件架构与设计模式》关于 抽象工厂模式 的一个小例子

下面是题目的要求：

根据上面的要求，我首先是画出了UML类图：

接着，根据上面的UML类图写出源代码：

1、抽象产品类

该类定义了产品的共性，所有的具体产品都要实现这个类

 abstract class Burger
    {
        public abstract void EatBurger();
    }


 abstract class Chicken
    {
        public abstract void EatChicken();
    }


abstract class Drink
    {
        public abstract void EatDrink();
    }

2、具体产品类

决定了产品在客户端中的具体行为

class KFCBurger : Burger
    {
        public override void EatBurger()
        {
            Console.WriteLine("I am eating KFC Burger");
        }
    }

    class McDonaldBurger : Burger
    {
        public override void EatBurger()
        {
            Console.WriteLine("i am eating McDonald Burger");
        }
    }

class KFCChicken : Chicken
    {
        public override void EatChicken()
        {
            Console.WriteLine("i am eating KFC Chicken");
        }
    }

    class McDonaldChicken : Chicken
    {
        public override void EatChicken()
        {
            Console.WriteLine("i am eating McDonlad Chicken");
        }
    }



 class KFCDrink : Drink
    {
        public override void EatDrink()
        {
            Console.WriteLine("i am eating KFC Drink");
        }
    }

    class McDonaldDrink : Drink
    {
        public override void EatDrink()
        {
            Console.WriteLine("i am eating McDonlad Drink");
        }
    }

3、抽象工厂类

定义了具体工厂必须实现的接口

interface IFactory
    {
        Burger MakeBurger();
        Chicken MakeChicken();
        Drink MakeDrink();
    }

4、具体工厂类

实现了如何具体的创建产品类

 class KFCFactory : IFactory
    {
        public Burger MakeBurger()
        {
            return new KFCBurger();
        }
        public Chicken MakeChicken()
        {
            return new KFCChicken();
        }
        public Drink MakeDrink()
        {
            return new KFCDrink();
        }
    }

    class McDonaldFactory : IFactory
    {
        public Burger MakeBurger()
        {
            return new McDonaldBurger();
        }
        public Chicken MakeChicken()
        {
            return new McDonaldChicken();
        }
        public Drink MakeDrink()
        {
            return new McDonaldDrink();
        }
    }

5、product 套餐类

class Product
    {
        private Burger _burger;
        private Chicken _chicken;
        private Drink _drink;

        public Burger burger
        {
            get { return _burger; }
            set { _burger = value; }
        }

        public Chicken chicken
        {
            get { return _chicken; }
            set { _chicken = value; }
        }
        public Drink drink
        {
            get { return _drink; }
            set { _drink = value; }
        }

        public void eatbypeople()
        {
            _burger.EatBurger();
            _chicken.EatChicken();
            _drink.EatDrink();

            Console.WriteLine("实在是太好吃了！");
        }


    }

6、客户端代码

            IFactory factory = null;

            Console.Write("请根据不同的 K/M ,来选择不同品牌的套餐");
            string Select = Console.ReadLine();

            switch (Select)
            {
                case "K":
                    factory = new KFCFactory();
                    break;
                case "M":
                    factory = new McDonaldFactory();
                    break;
            }

            Product product1 = new Product();
            product1.burger = factory.MakeBurger();
            product1.chicken = factory.MakeChicken();
            product1.drink = factory.MakeDrink();
            product1.eatbypeople();

            Console.ReadLine();

下面是具体的效果图：

从  简单工厂模式  到  工厂方法模式  再到现在的  抽象工厂模式

在这个过程的学习中，也体会到了各自模式的优缺点及改进的构成。

接下来谈一谈我自己的看法，欢迎大家指正。

我觉得上面的模式都是建立在 多态 的基础上实现的，

简单工厂模式以一个工厂类为核心来创建多个继承抽象产品类的具体产品类。但是工厂类的本身违背了开-闭原则

工厂方法模式就是对于简单工厂模式存在的缺点进行改进，将工厂类进行了继承，形成了抽象工厂类和具体工厂类，那么这样就符合了开-闭原则

而抽象工厂模式则是将工厂方法模式中具体工厂类中的工厂方法增多，变成了一组工厂方法。