什么是简单工厂模式？
简单工厂模式根据提供给它的数据，返回一个类的实例。通常它返回的类都是一个公共的父类或者接口对象。
简单工厂的作用是实例化对象，而不需要客户了解这个对象属于哪个具体的子类。简单工厂实例化的类具有相同的接口或基类，在子类比较固定并不需要扩展时，可以使用简单工厂。
优点：可以使用户根据参数获得相应的类实例，避免了直接实例化类，降低了耦合性；
缺点：实例化的类型在编译期间已经被确定，如果增加新类型，则需要修改工作，不符合OCP开闭原则。
简单工厂需要知道所有要生成的类型，当子类过多或者子类层次过多时不合适使用。
－－引自www.cnblogs.com/lmy-foolishbird/p/5443293.html
这里我们用简单的计算器来了解一下这个模式
public class OperationFuns
{
double numberA;
double numberB;
void Main() {
numberA = 10;
numberB = 2;
double result = OperationNum("+");
Debug.Log("结果：" + result);
}
private double OperationNum(string str) {
double result = 0;
switch (str)
{
case"+":
result = numberA + numberB;
break;
case "-":
result = numberA - numberB;
break;
case "*":
result = numberA * numberB;
break;
case "/":
result = numberA / numberB;
break;
}
return result;
}
}
这样我们就实现了一个简单的计算器功能，但是问题也来了，如果我们后期要加入新的计算方式，比较加个开根号，那我们又要去加Case吗？虽然这样也是可以，不过代码复用性就很差，耦合度也很高。把计算方法封装起来，把每总计算方式封装成单独的运算类，运算类有两个Number属性，用于计算器的前后数，还有一个GetResult虚方法，用来得到结果，每个计算类只要继承运算类，重写里成的GetResult方法，这样分离了业务与计算的逻辑，这样修改其中一个计算都不用更改其它计算。但是要怎么让计算器知道我要实例哪个算法呢？这里简单工厂模式就可以派上用场了。
计算基类
public class Operation {
private double numberA;
private double numberB;
//计算数A
public double NumberA {
get { return numberA; }
set { numberA = value; }
}
//计算数B
public double NumberB
{
get { return numberB; }
set { numberB = value; }
}
//得到结果
public virtual double GetResult() {
double result = 0;
return result;
}
}
各个算法
//加法
public class OperationAdd : Operation
{
public override double GetResult() {
double resoult = 0;
resoult = NumberA + NumberB;
return resoult;
}
}
//减法
public class OperationSub : Operation
{
public override double GetResult()
{
double resoult = 0;
resoult = NumberA - NumberB;
return resoult;
}
}
//乘法
public class OperationMul : Operation
{
public override double GetResult()
{
double resoult = 0;
resoult = NumberA * NumberB;
return resoult;
}
}
//除法
public class OperationDiv : Operation
{
public override double GetResult()
{
double resoult = 0;
resoult = NumberA / NumberB;
return resoult;
}
}
现在我们建立一个工厂类OperationFactory,工厂类的功能是根据我们的输入帮我们选择对应该的算法，所以我们可以写一个方法，传入我们的输入，写义好父类Operation,在想对应该的返回父类的实例。（因为我们只要传入参数得到最后的结果）。
public class OperationFactory {
public static Operation OperationNumber(string str)
{
Operation oper = null;
switch (str)
{
case "+":
oper = new OperationAdd();
break;
case "-":
oper = new OperationSub();
break;
case "*":
oper = new OperationMul();
break;
case "/":
oper = new OperationDiv();
break;
default:
Debug.Log("输入参数不正确");
break;
}
return oper;
}
}
这样我们就实现了简单工厂模式，客户端我们就只需要输入参数，再输入运算符到OperationFactory.OperationNumber()方法里，最后在Operation.GetResult()得到结果。
public class OperationView {
void Mian () {
double numA = 10;
double numB = 2;
Operation oper = OperationFactory.OperationNumber("/");
oper.NumberA = numA;
oper.NumberB = numA;
double result = oper.GetResult();
Debug.Log("结果：" + result);
}
}
总结：工厂是一个单独类创建实例的过程，这可以让我们的代码维护性变强，同时可以使耦合度降低，有时代码也是可以优雅的写出来的。
