抽象工厂模式

抽象工厂模式

一、简介

抽象工厂模式其实是简单工厂模式的升级版。相比之下，它遵循了 开闭原则 ，不像简单工厂，当我们增加一个新的类，就不用像原来简单工厂那样，修改工厂类。

二、简单的Demo

我们还是以简单工厂的例子为例，原来我们的红车、蓝车。如果要增加一个黒车，那么我们还要加一个类：

        /// <summary>
        /// 黒车
        /// </summary>
        public class BlackCar : Car
        {
            public override void run()
            {
                Console.WriteLine("I'm a BlackCar,I'm running!");
            }
        }

再修改一下 车工厂 类：

        /// <summary>
        /// 车工厂
        /// </summary>
        public class CarFactory
        {
            /// <summary>
            /// 根据车的颜色得到具体的车
            /// </summary>
            /// <param name="carColor"></param>
            /// <returns></returns>
            public static Car GetCar(string carColor)
            {
                Car ResultItem = null;
                switch (carColor)
                {
                    case "red":
                        ResultItem = new RedCar();
                        break;
                    case "blue":
                        ResultItem = new BlueCar();
                        break;
                    case "black":
                        ResultItem = new BlackCar();//增加黒车的判断
                        break;
                    default:
                        ResultItem = new DefaultCar();
                        break;
                }
                return ResultItem;
            }
        }

这样，我们是不是也完成了增加黒车的功能？

但是，我们违反了设计模式的六大原则：开闭原则。

现在我们引入了抽象工厂，让抽象工厂来帮助我们解决这个问题，让具体的工厂去生产车，由客户端来决定生产什么车，来完善一下我们的代码：

首先，写一个 抽象车工厂类 

        /// <summary>
        /// 抽象车工厂类
        /// </summary>
        public abstract class CarProductFactory
        {
            /// <summary>
            /// 抽象工厂方法
            /// </summary>
            /// <returns></returns>
            public abstract Car CreateCar();
        }

对应的车，完成对应的车工厂：

        /// <summary>
        /// 蓝车生产工厂
        /// </summary>
        public class BlueCarFactory : CarProductFactory
        {
            /// <summary>
            /// 生产车
            /// </summary>
            /// <returns></returns>
            public override Car CreateCar()
            {
                return new BlueCar();
            }
        }


        /// <summary>
        /// 红车生产工厂
        /// </summary>
        public class RedCarFactory : CarProductFactory
        {
            public override Car CreateCar()
            {
                return new RedCar();
            }
        }


        /// <summary>
        /// 黒车生产工厂
        /// </summary>
        public class BlackCarFactory : CarProductFactory
        {
            public override Car CreateCar()
            {
                return new BlackCar();
            }
        }

接下来，我们来改一下调用的地方：

        static void Main(string[] args)
        {

            CarProductFactory blueCarFactory = new BlueCarFactory();
            Car blueCar= blueCarFactory.CreateCar();
            blueCar.run();


            CarProductFactory redCarFactory = new RedCarFactory();
            Car redCar= redCarFactory.CreateCar();
            redCar.run();


            CarProductFactory blackCarFactory = new BlackCarFactory();
            Car blackCar = blackCarFactory.CreateCar();
            blackCar.run();

            Console.Read();
        }    

就这样，我们修改完成了。

三、小结

简单说一下思路（基于我们做好的简单工厂修改）：

1.创建一个抽象的实现生成实际工厂的工厂类

2.实现具体的生成类的工厂类（也就是我们的红车工厂类、蓝车工厂类、黒车工厂类）

3.将原简单工厂生成类中的判断逻辑，移交给客户端，让客户端决定调用哪个工厂类去生成对应的数据。