设计模式之简单工厂模式

设计模式之简单工厂模式

设计模式主要是为了面向对象编程提供服务的，面向对象编程就是通过封装、继承、多态把程序的耦合度降低，使得程序可维护，可复用，可扩展，灵活性好。

简单工厂模式之计算器实例

未使用设计模式时

class Program
{
    Console.Write("请输入数字A：");
    string A = Console.Readline();  //命名不规范
    Console.Write("请选择运算符号(+、-、*、/)：");
    string B = Console.Readline();
    Console.Write("请输入数字B：");
    string C = Console.Readline();
    string D = "";

    if (B == "+")  //判断分支时每个分支都需要判断，多做了无用功
        D = Convert.ToString(Convert.ToDouble(A) + Convert.ToDouble(C));
    if (B == "-")
        D = Convert.ToString(Convert.ToDouble(A) - Convert.ToDouble(C));
    if (B == "*")
        D = Convert.ToString(Convert.ToDouble(A) * Convert.ToDouble(C));
    if (B == "/")  
        D = Convert.ToString(Convert.ToDouble(A) / Convert.ToDouble(C));  //未考虑除数为0或输入不是数字的情况

    Console.WriteLine("结果是：" + D);
}

针对注释中提出的问题，下方的代码进行了改善，同时也使用了面向对象的封装、继承与多态来提高了代码的安全性与灵活性。

使用简单工厂模式时

Operation 运算类（将运算操作封装起来）

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 double GetResult() //虚函数，用于得到结果
    {
        double result = 0;
        return result;
    }
}

加减乘除类（继承Operation类）

class OperationAdd : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA + NumberB;
        return result;
    }
}

class OperationSub : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA - NumberB;
        return result;
    }
}

class OperationMul : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA * NumberB;
        return result;
    }
}

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

简单运算工厂类（通过运算符号实例化出相应的对象，通过多态，返回父类）

public 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;
    }
}

客户端代码（根据输入新建对象，并实现计算）

static void Main(string[] args)
{
    try
    {
        //从界面获得输入
        Console.Write("请输入数字A：");
        string strNumberA = Console.Readline();  
        Console.Write("请选择运算符号(+、-、*、/)：");
        string strOperate = Console.Readline();
        Console.Write("请输入数字B：");
        string strNumberB = Console.Readline();

        //新建计算器对象进行计算
        Operation oper;
        oper = OperationFactory.createOperate(strOperate);
        oper.NumberA = Convert.ToDouble(strNumberA);
        oper.NumberB = Convert.ToDouble(strNumberB);
        double result = oper.GetResult();

        //将结果返回显示到界面上
        string strResult = Convert.ToString(result);
        Console.WriteLine("结果是：" + strResult);
        Console.Readline();
    }
    catch (Exception ex)
    {
        Console.WriteLine("您的输入有错：" + ex.Message);
    }
}

使用简单工厂模式后的优点

• 通过对Operation的封装将计算过程与显示分开，使得不同的显示界面下都可以复用这个Operation类
• 使用继承与多态，将加减乘除实现为四个Operaion的子类，使得再添加其他运算（如开根sqrt运算）时不需要接触与修改已实现的子运算，避免了误操作，也更加的方便灵活。
• 使用一个单独的类（简单工厂类）来实现创造实例化的过程，判断哪种情况下需要使用哪种子类。

注：本文是阅读《大化设计模式》一书后的个人心得总结，更详细内容请参考该书作者程杰的个人博客。