《大话设计模式》学习笔记--简单工厂模式

问题描述:利用面向对象语言实现一个计算器控制台程序,要求输入两个数和运算符号,得到结果.

初学者版本

namespace jiandangongchang
{
    class Program
    {
        static void Main(string[] args)
        {          
            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));

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

初学者版本的问题在于:
(1)变量命名不规范:A,B,C意义不够明确;
(2)利用if写判断分支,每个条件都要进行判断,做无用功;
(3)没有考虑输入错误的情况.

简单修改过的初学者版本

namespace jiandangongchang
{
    class Program
    {
        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();
                string strResult = "";
                switch (strOperate)
                {
                    case "+":
                        strResult = Convert.ToString(Convert.ToDouble(strNumberA) + Convert.ToDouble(strNumberB));
                        break;
                    case "-":
                        strResult = Convert.ToString(Convert.ToDouble(strNumberA) - Convert.ToDouble(strNumberB));
                        break;
                    case "*":
                        strResult = Convert.ToString(Convert.ToDouble(strNumberA) * Convert.ToDouble(strNumberB));
                        break;
                    case "/":
                        if (strNumberB != "0")
                            strResult = Convert.ToString(Convert.ToDouble(strNumberA) / Convert.ToDouble(strNumberB));
                        else
                            strResult = "除数不能为0";
                        break;
                }
                Console.WriteLine("结果是：" + strResult);
                Console.ReadLine();
            }
            catch (Exception ex)
            {
                Console.WriteLine("您的输入有错：" + ex.Message);
            }
        }
  	}
}           

这一版对于之前的修改了代码规范上的问题,但是没有体现出面向对象的编程思路,不容易维护,不容易扩展,更不易复用.
考虑通过封装,继承,多态把程序的耦合度降低.

业务逻辑与界面逻辑分开

//operation 运算类
public class operation
{
    public static double getresult(double numbera, double numberb, string operate)
    {
        double result = 0d;
        switch (operate)
        {
            case "+":
                result = numbera + numberb;
                break;
            case "-":
                result = numbera - numberb;
                break;
            case "*":
                result = numbera * numberb;
                break;
            case "/":
                result = numbera / numberb;
                break;
        }
        return result;
    }
}

namespace jiandangongchang
{
    class Program
    {
    	//客户端代码
        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();
                string strResult = "";
                strResult = Convert.ToString(Operation.GetResult(Convert.ToDouble(strNumberA), Convert.ToDouble(strNumberB),
                                             strOperate));
                Console.WriteLine("结果是：" + strResult);
                Console.ReadLine();
            }
            catch (Exception ex)
            {
                Console.WriteLine("您的输入有错：" + ex.Message);
            }
        }      
    }
}     

这一版已经实现了封装,但是还是不够,如果对于其中一种运算进行修改或者添加运算,所有运算都要参与编译.下面对于运算也进行分离,修改其中之一不会影响其余运算.

分离各类运算的代码

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

//加减乘除类
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;
    }
}

利用这个简单工厂类,便可以根据运算符号来实例化出合适的对象,通过多态,返回父类的方式实现了计算器的效果.

	Operation oper;
    oper = OperationFactory.createOperate("+");
    oper.NumberA = 1;
    oper.NumberB = 2;
    double result = oper.GetResult();
    Console.WriteLine("结果是：" + result);

以上,便是一个通过简单工厂模式实现计算器控制台程序的示例.
简而言之,简单工厂模式就是定义一个工厂类，可以根据不同参数返回不同类的实例从而实现程序功能，这里被创建的实例往往都具有共同的父类.

参考书籍:《大话设计模式》