设计模式——简单工厂模式(本人摘录文章)

　简单工厂模式可以说重面向过程转向面向对象的一个比较典型的模式，这是一个基本实现了类的继承和多态的模型，并且最后可进行封装，简单工厂模式并不是很难，但是却很有用。下面是我理解的具体的内容和代码：

1.创建Opretation操作类，这是一个父类，它不具体实现什么，可以说只是一个实体类。

/// <summary>
/// 这是一个父类，主要作用是获取参数值，
/// 定义一个抽象方法，给子类进行重写
/// </summary>
public class Operation
{
private double numberA = 0;
/// <summary>
/// 用于运算的参数A
/// </summary>
public double NumberA
{
get { return numberA; }
set { numberA = value; }
}

private double numberB = 0;
/// <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;
}
}

Operation.cs

2.下面是一些具体实现方法的类，他们的作用就是做真正的运算，参数来自于它们的父类：Operation:

/// <summary>
/// 加法运算实现类
/// </summary>
public class OperationAdd : Operation
{
/// <summary>
/// 加法运算实现方法
/// </summary>
/// <returns>运算结果</returns>
public override double GetResult()
{
double result = 0;
result = NumberA + NumberB;
return result;
}
}
/// <summary>
/// 减法运算实现类
/// </summary>
public class OperationSub : Operation
{
/// <summary>
/// 减法运算实现方法
/// </summary>
/// <returns>运算结果</returns>
public override double GetResult()
{
double result = 0;
result = NumberA + NumberB;
return result;
}
}
/// <summary>
/// 乘法运算实现类
/// </summary>
public class OperationMul : Operation
{
/// <summary>
/// 乘法运算实现方法
/// </summary>
/// <returns>运算结果</returns>
public override double GetResult()
{
double result = 0;
result = NumberA * NumberB;
return result;
}
}
/// <summary>
/// 除法运算实现类
/// </summary>
public class OperationDiv : Operation
{
/// <summary>
/// 除法运算实现方法
/// </summary>
/// <returns>运算结果</returns>
public override double GetResult()
{
double result = 0;
if (NumberB != 0)
{
result = NumberA / NumberB;
}
else
{
throw new Exception("除数不能为0");
}
return result;
}
}

OprationProduct.cs

3.然后就到了简单抽象模式最重要的一个类了，工厂类，它的代码很少，却非常重要，它实现了一个工厂的职责，那就是生产对象：

/// <summary>
/// 这是一个创建类的工厂，我们需要实现功能的子类通过这里创建
/// 这样，降低了耦合性，大大增加了扩展性
/// </summary>
public class OperationFactory
{
/// <summary>
/// 这是一个创建子类的具体实现方法
/// </summary>
/// <param name="operate"></param>
/// <returns>具体实现功能的子类对象</returns>
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:
throw new Exception("运算符不存在");
}
return oper;
}
}

OperationFactory

4.最后就是UI层的代码了，功能都有工厂实现了，那么UI层就不需要干多少活啦，它通过工厂类创建了对象，然后调用虚方法来具体实现，等结果就OK啦！

class SimpleFactoryDefault
{
public static void Main()
{
string operate="+";
Operation oper;
oper = OperationFactory.createOperate(operate);
oper.NumberA = 1;
oper.NumberB = 2;
double result = oper.GetResult();
Console.WriteLine("您输入的运算符为：{0}，运算结果为：{1}",operate,result.ToString());
Console.ReadKey();
}
}

SimpleFactoryDefault

最后，当我们要实现更多的方法的时候，只要创建具体实现的子类，然后修改OperationFactory,增加一个switch分支就可以了，大大降低了代码的耦合性，而且便于日后维护。

　　简单工厂模式其实正如其名，是很简单的，用处却特别大，目前我觉得它用的最多的地方是大量创建同类对象的地方，然后方便进行管理，同时当我需要修改一个方法的具体实现时，并不会影响其他方法，那么我们就少了很多的测试，减少了我们的工作量