简单工厂模式

1.工厂模式.

　　实例:计算器

　　创建方法:

首先是运算类,它有两个Number属性,用于计算计算器的前后数;

然后有一个虚方法GetResult,用于得到结果;

//运算类
{
    两个Number属性{get;set;} //主要用于计算前后数,NumA,NumB
    虚方法GetResult//用于得到结果
}

把加减乘除都写成子运算类的子类,继承它,重写了GetResult()方法,

运算类子类:运算类//运算类子类  继承  运算类
 {
    //重写GetRsult方法
    运算类子类1//这里 如果不写  就为 private
    {
        public overrive 运算方法{};
        //切记这里是public,上面一行不要加public,不加就是默认private.  加了之后会报错.访问级别导致不知道要访问overrive之前的还是现在的方法
    }
     运算类子类2
    {
        public overrive 运算方法{};
    }
    运算类子类3
    {
        public overrive 运算方法{};
    }
}

这样如果要修改任何一个算法，都不需要提供其它算法的代码了.

让计算器指导我是希望用哪一种算法:

运算类工厂
{
    public static 运算类 CreateFunction(string 传入参数)//切记前面的static不能忘了,返回值类型为  运算类
    {
        运算类 my=null;
        switch(传入参数)
        {
           case "+":
               my=new 运算子类1();
               break;
           case "-":
               my=new 运算子类2();
               break;
           case "*":
               my=new 运算子类3();
               break;
        }
           return my;//返回  运算类  类型
    }

}

在Program中调用,只要输入运算符号,用工厂实例化合适的对象,通过多台,返回父类的方式实现计算器的结果.

//Program.cs

运算类 mynew;
mynew=运算类工厂.CreateFunction("传入的值");
mynew.NumA=数字A;
mynew.Numb=数字B;
Console.WriteLine(mynew.GetResult().toString());

这样 需要增加各种复杂运算，比如平方根，立方根，自然对数，正弦余弦等，只要增加相应的运算子类就可以了.

完整代码:

/**//// <summary>
/// 运算类
/// </summary>
class Operation
{
    private double _numberA = 0;
    private double _numberB = 0;

    /**//// <summary>
    /// 数字A
    /// </summary>
    public double NumberA
    {
        get{ return _numberA; }
        set{ _numberA = value;}
    }

    /**//// <summary>
    /// 数字B
    /// </summary>
    public double NumberB
    {
        get{ return _numberB; }
        set{ _numberB = value; }
    }

    /**//// <summary>
    /// 得到运算结果
    /// </summary>
    /// <returns></returns>
    public virtual double GetResult()
    {
        double result = 0; 
        return result;
    }


}

//运算类View Code

/**//// <summary>
/// 加法类
/// </summary>
class OperationAdd : Operation
{
    public override double GetResult()
    {
        double result = 0; 
        result = NumberA + NumberB;
        return result;
    }
}

/**//// <summary>
/// 减法类
/// </summary>
class OperationSub : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA - NumberB;
        return result;
    }
}

/**//// <summary>
/// 乘法类
/// </summary>
class OperationMul : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA * NumberB;
        return result;
    }
}

/**//// <summary>
/// 除法类
/// </summary>
class OperationDiv : Operation
{
    public override double GetResult()
    {
        double result = 0;
        if (NumberB==0)
            throw new Exception("除数不能为0。");
        result = NumberA / NumberB;
        return result;
    }
}

//运算子类 View Code

/**//// <summary>
/// 运算类工厂
/// </summary>
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;
                }
            }

        return oper;
    }
}

//运算类工厂 View Code

Operation oper;
oper = OperationFactory.createOperate("+");
oper.NumberA = 1;
oper.NumberB = 2;
double result = oper.GetResult();

工厂模式和策略模式的区别:

策略，从字面就好理解，意思是一种决策，所以通常它都适用于一些商务逻辑或算法等类的选择上，因此只要是一些涉及到商务逻辑（都是继承同一个抽象类的子类）的选择时，都可以考虑用策略模式。从这个角度讲，策略模式在面向对象编程中的应用可说是无处不在，它是最最常见的模式。

而简单工厂模式，主要解决的是类的实例化问题，把实例化的决策从客户端转移到工厂类当中，让客户端只是输入一个比如“字符串”这样的标识就可以通过简单工厂生成一个相应的类实例。这个模式是解决类的创建问题。

它们两者并不矛盾，因此不要有非此即彼的想法。事实上把它们结合使用会更有意义。

参考:大话设计模式