什么是简单工厂模式？

简单工厂模式根据提供给它的数据，返回一个类的实例。通常它返回的类都是一个公共的父类或者接口对象。

简单工厂的作用是实例化对象，而不需要客户了解这个对象属于哪个具体的子类。简单工厂实例化的类具有相同的接口或基类，在子类比较固定并不需要扩展时，可以使用简单工厂。

优点：可以使用户根据参数获得相应的类实例，避免了直接实例化类，降低了耦合性；

缺点：实例化的类型在编译期间已经被确定，如果增加新类型，则需要修改工作，不符合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);
    }
}

总结：工厂是一个单独类创建实例的过程，这可以让我们的代码维护性变强，同时可以使耦合度降低，有时代码也是可以优雅的写出来的。