工厂方法模式 - OK

　　工厂方法模式(Factory Method)，定义了一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到子类。

　　工厂方法模式在实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还存在，也就是说，工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。想要加功能，本来是修改工厂类的，而现在是修改客户端。

　　下面给出工厂方法模式UML图：

　　　　

　　工厂方法模式示例：

namespace 工厂方法模式
{
    //数据库类
    class DataBase
    {
        public virtual string SelectTopOne()
        {
            return "SELECT TOP 1 * FROM Table";
        }
    }

    //SQLServer类
    class SQLServer : DataBase
    {
        public override string SelectTopOne()
        {
            return "SELECT TOP 1 * FROM Table";
        }
    }

    //Oracle类
    class Oracle : DataBase
    {
        public override string SelectTopOne()
        {
            return "SELECT * FROM Table WHERE ROWRUM <= 1";
        }
    }

    //总结来说，下面的1个接口两个类实现的就是简单工厂中switch的功能
    //数据库工厂
    interface IFactory
    {
        DataBase GetDataBase();
    }

    //SQLServer工厂
    class SQLServerFactory : IFactory
    {
        public DataBase GetDataBase() { return new SQLServer(); }
    }

    //Oracle工厂
    class OracleFactory : IFactory
    {
        public DataBase GetDataBase() { return new Oracle(); }
    }

    class Program
    {
        static void Main(string[] args)
        {
            IFactory factory = new SQLServerFactory();   //依赖于具体工厂类，但不依赖具体实现了了
            DataBase DB = factory.GetDataBase();         //从获得的工厂中 获取学雷锋对象
            Console.WriteLine(DB.SelectTopOne());

            //但是我有一种很强烈的感觉，既然如此，何不这样,虽然依赖了具体实现类，但是少了3个类
            //DataBase DB = new SQLServer();
            //Console.WriteLine(DB.SelectTopOne());

            Console.ReadKey();
        }
    }
}

　　类图如下：

　　

　　为了对比与简单工厂模式的区别，以下再写个简单工厂模式的来比较下：

namespace 简单工厂
{
    public class Program
    {
        static void Main(string[] args)
        {
            DataBase DB = SimpleFactory.GetInstance("Oracle");
            Console.WriteLine(DB.SelectTopOne());

            DataBase DB2 = SimpleFactory.GetInstance("SQLServer");
            Console.WriteLine(DB2.SelectTopOne());

            Console.ReadKey();
        }
    }

    //简单工厂类，判断类，用于返回对应的的对象
    public class SimpleFactory
    {
        public static DataBase GetInstance(string type)
        {
            DataBase db = null;
            switch (type)
            {
                default:
                case "SQLServer":
                    db = new SQLServer();
                    break;
                case "Oracle":
                    db = new Oracle();
                    break;
            }
            return db;
        }
    }

    //基类
    public class DataBase
    { 
        public virtual string SelectTopOne()
        {
            return "SELECT TOP 1 * FROM Table";
        }
    }

    //实现类1
    public class SQLServer : DataBase
    {
        public override string SelectTopOne()
        {
            return "SELECT TOP 1 * FROM Table";
        }
    }

    //实现类2
    public class Oracle : DataBase
    {
        public override string SelectTopOne()
        {
            return "SELECT * FROM Table WHERE ROWRUM <= 1";
        }
    }
}

　　比较一下，两者实现的代码类似。

　　对于简单工厂模式，在客户端方面，去除了对具体雷锋的依赖，即可以不出现具体的雷锋类(如大学生，社区志愿者)。但如果要添加一个学雷锋的中学生，就需要修改工厂类里面的case判断，以及添加一个具体类。

　　对于工厂方法模式，由客户端方面来决定实例化哪一个工厂来实现运算类，当然判断的问题还是存在。相比于简单工厂，判断的工作交到客户端来处理。但是有一个好处，就是当需要添加一个DB2实现时，就没有必要再修改原有的工厂类，只需要添加一个工厂类（这就是为何这么多工厂类，一个实现类就有一个工厂类），以及具体类(如例子中的SQLServer、Oracle)。

　　客户端new的地方。相对于简单工厂而言，对修改封闭了，符合开放封闭原则。但是带来了代价就是类比较多(工厂类太多了，找死你)。