设计模式——简单工厂、工厂方法与抽象工厂

　　在设计模式中，如果说最简单的应该是单一职责模式（私有化构造方法。增加获取类实例的公共方法，但其中限制了实例化的个数）。但是要说具有学习价值，又是入门必备的话，我推荐是简单工厂、工厂方法与抽象工厂这三个创建型的设计模式，并进行相互比较的学习。

　　简单工厂模式，其实算不上模式，既然都叫“简单”了，当然简单咯。简单工厂主要是对一类问题抽象一个父类（父类的方法一般为虚方法），然后基于这个父类创建子类们，然后在创建子类的时候，通过条件判断选择合适的子类。简单工厂模式的好处是，通过对子类的封装，增加了子类的封闭性，避免子类被随便更改。对外暴露的是工厂类，对后期扩展性，更加灵活、开放。现在举个简单工厂的例子，通过计算器的实现说明简单工厂的好处。如果在项目中，采用分层模式，UI层为一层（Winfrom或控制台），业务代码（计算器逻辑）为一层（类库）。其中业务层代码如下（现实开发中每个类为一个单独文件）：

　　先创建计算器运算基类。

 public class Operation
    {
        public double NumA { set; get; }
        public double NumB { set; get; }
        public virtual double GetResult() 
        {
            double result = 0;
            return result;
        }
    }

　　接着以此创建运算的子类逻辑。这里只列举加减算法的子类。

public class OperationAdd : Operation
    {
        public override double GetResult()
        {
            double result = NumA + NumB;
            return result;
        }
    }

    public class OperationSub : Operation
    {
        public override double GetResult()
        {
            double result = NumA + NumB;
            return result;
        }
    }

　　下面增加子类选择的工厂类。

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

　　最后增加客户端调用的代码。

static void Main(string[] args)
        {
            Operation oper = null;
            oper = OperationFactory.createOperation("+");
            if (oper != null)//对外部类库(方法)使用，先判断是否为Null，防御性编程。
            {
                oper.NumA = 1;
                oper.NumB = 2;
                double result = oper.GetResult();
            }
        }

　　时间有点晚，今天先到这里。明天继续工厂方法与抽象工厂。感谢程杰老师的《大话设计模式》。

　　继续昨天的学习，简单工厂实习了计算器的业务逻辑与UI（控制台程序）的分类，封装的运算子类都继承了运算的基类，便于扩展性。以后增加一个除法，只需要增加一个继承运算基类的除法子类，然后在工厂类里增加创建除非子类的条件。然后这样就好了吗？没有最好，只有更好。工厂方法实际上是简单工厂的再次抽象，对简单工厂的选择逻辑进行抽象。先定义获取运算的工厂接口，然后创建加、减的子类工厂去引用（实现）工厂接口。在客户端调用的时候，都可以根据业务需要调用不同的子类工厂，创建运算，获取运算业务类。

　　工厂方法接口以及子类工厂方法代码如下：

public interface IFactory
    {
        Operation CreateOperation();
    }

    public class AddFactory : IFactory
    {

        public Operation CreateOperation()
        {
            return new OperationAdd();
        }
    }

    public class SubFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationSub();
        }
    }

　　客户端调用代码如下：

  //加法算法
            IFactory operFactory = new AddFactory();
            Operation oper = operFactory.CreateOperation();
            if (oper != null)
            {
                oper.NumA = 1;
                oper.NumB = 2;
                double result = oper.GetResult();
            }

　　由此，可见简单工厂在选择需要的子类时，总是需要case去判定，客户端需要传入case的条件，更改起来两边都要更改，违背了开放--关闭的原则。而工厂方法，创建了工厂接口契约，然后创建了各个运算的子工厂方法来实现工厂接口契约，在子工厂方法里，来创建各自的业务运算类。客户端定义了工厂接口变量，根据需要赋其子类工厂，然后通过这个接口变量（已经new了子类工厂）去获取最终的运算类，最终通过运算类的变量实现加、减算法。