计算器的简单工厂和工厂方法

      设计模式这本书学了一多半了，心里也迷糊迷糊的，不过这在怎么迷糊也得总结啊，先从第一个简单工厂开始吧。简单工厂模式是进入设计模式世界的第一个模式，他也告诉了我们面向对象设计时的法则。首先简单工厂模式告诉我们在设计程序时要尽量复用，其次要封装，把业务逻辑和界面逻辑分开，降低耦合度，利于扩展和维护。其实在简单工厂中也隐含了单一职责的原则，比如：加减乘除各是一个类，各自处理自己的算法。下面举一个计算器的例子

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 简单工厂     //命名空间，
{
    class Program      //用户界面程序入口
    {
        static void Main(string[] args)
        {
            Operation oper;
            oper = OperationFactory.creatOperation ("+");     
            oper.NumberA = 3;
            oper.NumberB=4;
            //Console .WriteLine ("结果={0}",oper.GetResult ());
            oper.GetResult();

        }
    }
}
public class Operation           //运算类   基类
{
    private double numberA = 0;
    //public double numberA = 0;
    private double numberB = 0;
    public double NumberA          //给属性赋值
    {
        get { return numberA; }
        set { numberA = value; }
    }
    public double NumberB            //给属性赋值
    {
        get { return numberB; }
        set { numberB = value; }
    }
    public virtual void  GetResult();    //输出结果方法   virtual关键字使用  虚方法
    
}
 class OperationAdd:Operation  //类默认修饰符是protected    加法类
{
     public override  void  GetResult()       //override关键字使用  
     {
         double result = 0;
         result = NumberA + NumberB;
         Console.WriteLine(NumberB + "+" + NumberA + "={0}", result);
        
     }
}
 class OperationSub : Operation   //减法类
 {
     public override void GetResult()         
     {
         double result = 0;
         result = NumberA - NumberB;
<span style="white-space:pre">	</span>Console.WriteLine(NumberA + "-" + NumberB "={0}",result);
     }
 }
public class OperationFactory          //运算工厂，根据客户端，实例化运算类的子类
{
    public static Operation creatOperation(string operate)     //传入字符。选择实例化哪个子类
    {
        Operation oper = null;
        switch (operate)            
        {
            case "+":
                oper = new OperationAdd();         //new关键字 加法类的实例化
                break;
            case "-":
                oper = new OperationSub();        
                break;
        }
        return oper;                                    //返回对象，可以使用对象的方法。
    }
}

简单工厂模式挺简单的，意在告诉我们编程设计时要多注意封装，复用，降低耦合。

学着学着，又遇到个工厂方法模式，这个模式算是对简单工厂的提升，进一步提高了整个程序的耦合度。在简单工厂模式中，如果要加入乘法，我们必须修改客户端的代码，也要增加一个乘法子类，而且在工厂中也要增加一个case语句，很显然整个程序之间的耦合度还不够低。而工厂方法进一步降低了整个程序的耦合度，下面看代码。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 工厂方法
{
    class Program         //客户端程序
    {
        static void Main(string[] args)    
        {
            IFactory factory= new operationAddIFactory ();
            Operation suanfa = factory .CreateOperation ();
            suanfa.NumberA = 3;
            suanfa.NumberB = 4;
            suanfa.GetResult();


        }
    }
}
public class Operation         //运算类，基类
{
    private double numberA = 0;
    private double numberB = 0;
    public double NumberA
    {
        get { return numberA; }
        set { numberA = value; }
    }
    public double NumberB
    {
        get { return numberB; }
        set { numberB = value; }
    }
    public virtual void GetResult()      //虚方法
    {

    }
} 
interface IFactory               //工厂接口  
{
     Operation CreateOperation();
}
class operationAddIFactory:IFactory   //加法工厂类，实现接口中的方法。
{
    public Operation CreateOperation()      //实现接口的方法 ，返回加法子类
    {
        return new Add ();
    }
}
class operationSubIFactory:IFactory      //减法工厂类，实现接口中的方法
{
    public Operation CreateOperation()  //实现接口的方法，返回减法类
    {
        return new Sub ();
    }
}

class Add:Operation   // 加法类
{
    public override void GetResult()	 
    {
        double result=0;
        result =NumberA +NumberB ;
        Console .WriteLine (NumberA +"+"+NumberB +"={0}",result );
    }
}
class Sub:Operation   //减法类
{
    public override void GetResult()
    {
 	double result=0;
        result =NumberA -NumberB;
        Console .WriteLine (NumberA +"-"+NumberB +"={0}",result );
    }
}

通过上面的代码，我们知道如果要增加一个乘法，我们只需要增加一个乘法子类和乘法工厂就可以了，而不需要修改什么，这极大的符合了开闭原则。所以，工厂方法要比简单工厂好多了。