简单工厂、工厂方法和抽象工厂

简单工厂：

就是将复杂的判断交予工厂类去实现，不需要用户关心。

简单工厂关键代码

class OperationFactory
    {
        public static Operation createOperate(string operate)
        {
            Operation oper = null;
            switch (operate)
            {
                case "+":
                    oper = new OperationAdd();
                    break;
                case "-":
                    oper = new OperationSub();
                    break;
                case "*":
                    oper = new OperationMul();
                    break;
                case "/":
                    oper = new OperationDiv();
                    break;
                default:
                    break;
            }
            return oper;
        }
    }

工厂方法

需要创建的产品也统一一个接口，这样就实现了通过让 子类 决定该创建的对象是什么，来达到将对象创建的过程封装的目的。这样，关于超类的代码和子类创建对象的代码之间就解耦了。

实例：

工厂类

 {
    interface IFactory
    {
        LeiFeng CreateLeiFeng();
    }
    class undergraduateFactory : IFactory
    {
        public LeiFeng CreateLeiFeng()
        {
            return new Undergraduate();
        }
    }
    class VolunteerFactory : IFactory
    {
        public LeiFeng CreateLeiFeng()
        {
            return new Volunteer();
        }
    }

产品类

     class LeiFeng
    {
        public void Sweep()
        {
            Console.WriteLine("扫地");
        }
        public void Wash()
        {
            Console.WriteLine("洗衣服");
        }
        public void BuyRice()
        {
            Console.WriteLine("买米");
        }
    }
    class Undergraduate : LeiFeng { }
    class Volunteer : LeiFeng { }

调用

             IFactory factory = new undergraduateFactory();
            LeiFeng student = factory.CreateLeiFeng();

            student.BuyRice();
            student.Sweep();
            student.Wash();

            Console.WriteLine();

抽象工厂

和工厂方法类似，提供一个接口，用来创建相关或依赖对象的家族，而不需要明确指定具体类。这样，产品创建的过程只会依赖于接口，而不关心具体的实现是什么，从而达到解耦的目的。

产品类

     interface IUser
    {
        void Insert(User user);
        User GetUser(int id);
    }
    class SqlserverUser : IUser
    {
        public void Insert(User user)
        {
            Console.WriteLine("sql插入一个用户");
        }
        public User GetUser(int id)
        {
            Console.WriteLine("sql根据ID查询用户");
            return null;
        }
    }
    class MysqlserverUser : IUser
    {
        public void Insert(User user)
        {
            Console.WriteLine("Mysql插入一个用户");
        }
        public User GetUser(int id)
        {
            Console.WriteLine("Mysql根据ID查询用户");
            return null;
        }
    }

反射实现的实例化工厂

     class AbstractFactorySQL
    {
        private static readonly string AssemblyName = "AbstractFactory";
        private static readonly string db = ConfigurationManager.AppSettings["DB"];
        public static IUser CreateUser()
        {
            string ClassName = AssemblyName + "." + db + "User";
            return (IUser)Assembly.Load(AssemblyName).CreateInstance(ClassName);
        }
        public static Department CreateDepartment()
        {
            string ClassName = AssemblyName + "." + db + "Department";
            return (Department)Assembly.Load(AssemblyName).CreateInstance(ClassName);
        }

    }

通过反射可以实现实例化自由，这里写的是用config文件获取需要实例化的类。

抽象工厂和工厂方法 很像，一开始看也有点懵。

这是找来的对比

下面参考博客：点这里

个人觉得这个区别在于产品，如果产品单一，最合适用工厂模式，但是如果有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。再通俗深化理解下：工厂模式针对的是一个产品等级结构 ，抽象工厂模式针对的是面向多个产品等级结构的。

举个例子说明下：

用种蔬菜的例子来说明事实，最初的时候，由于规模小，只种植一种蔬菜，根菜类蔬菜，这个时候由于种植方式比较简单，采用简单工厂模式即可，主要目的是让工人轻松，下达工厂种植即可，但是随着种植厂的发展以及市场的需求，要增加一种蔬菜类型种植了，茎菜，由于茎菜与根菜种植方式不一致，就需要两个专门的种植工厂来进行管理，那么久采用工厂模式来管理，一个工厂负责一种作物的种植，这个时候产品可以理解为仍然在一个层次。但是随着科技的发展，我们逐步要种植转基因与非转基因食品了，在以前的蔬菜种类上又增加了一个层次，这个时候无法将其作为一个层次来解决，所以必须采用抽象工厂的方式来解决。我用UML图表示三种结构：

上面的UML图很明显的就看出来了，抽象工厂可以创建多个产品类对象，如在种菜工厂中，有种根菜，种茎菜。工厂模式与抽象工厂模式以及简单工厂模式只有在具体应用的时候，分析具体的产品层级，然后选择相应的设计模式。

    而在没一个层次，种菜工人所关心的对象也不一样，在简单工厂模式下，工人要想到种植萝卜还是白菜，在工厂模式下，工人想到是种植根菜还是茎菜，而在抽象工厂模式下，则关心种植基因菜还是非基因菜。