《大话设计模式》笔记1

今天读了程杰老师所著的《大话设计模式》第一章，对设计模式有了初步的了解。打算之后每学完一章就写一篇笔记，加深对设计模式的印象。
在这本书中，作者通过小菜和大鸟两个人的对话，向我们描述了设计模式。第一章以小菜面试失败拉开序幕，小菜向大鸟请教一道面试题“请用C++、Java、C#或VB.NET任意一种面向对象语言实现一个计算器控制台程序，要求输入两个数和运算符号，得到结果”。这题目乍一看很简单，具体的思想是：首先获取到用户输入的两个数字和运算符号，然后通过条件判断语句判断该运算符号类型，根据类型进行相应的算数运算。该方法看似简单，但如果需要增加开方运算或者求余运算时，需要改变原来的代码结构，增加分支，这对代码来说不利于可维护。因此可考虑使用面向对象的思想，把操作抽象成一个类，然后用加操作、减操作、乘操作等继承该操作基类。这样以后要新增加一个操作如开方操作，只需新增一个开方操作类并继承自基类。
当进行到这一步时，问题又来了。现在有这么多子类，我怎么让计算机知道我要调用那个算法呢？而且将来会不会增加实例化的对象，比如增加开方运算？这个是很容易变化的地方，这个时候就要考虑用一个单独的类来做这个创造实例的过程，这个就是简单工厂。
用简单工厂来实现上述面试题得到的UML类图如下：

由图中可知AddOperator、SubOperator、MulOperator、DivOperator继承自BaseOperator类，用户可通过运算工厂类OperatorFactory得到BaseOperator实例。具体代码如下：

using System;

namespace SimpleFactory
{
    /// <summary>
    /// 运算基类
    /// </summary>
    abstract class BaseOperator
    {
        private int _numA;
        private int _numB;

        public int NumA
        {
            set { _numA = value; }
            get { return _numA; }
        }

        public int NumB
        {
            set { _numB = value; }
            get { return _numB; }
        }

        public virtual int GetResult()
        {
            int result = 0;
            return result;
        }
    }

    /// <summary>
    /// 加法运算
    /// </summary>
    class AddOperator : BaseOperator
    {
        public override int GetResult()
        {
            int result = NumA + NumB;
            return result;
        }
    }

    /// <summary>
    /// 减法运算
    /// </summary>
    class SubOperator : BaseOperator
    {
        public override int GetResult()
        {
            int result = NumA - NumB;
            return result;
        }
    }

    /// <summary>
    /// 乘法运算
    /// </summary>
    class MulOperator : BaseOperator
    {
        public override int GetResult()
        {
            int result = NumA * NumB;
            return result;
        }
    }

    /// <summary>
    /// 除法运算
    /// </summary>
    class DivOperator : BaseOperator
    {
        public override int GetResult()
        {
            if (NumB == 0)
            {
                throw new Exception("被除数不能为0");
            }
            int result = NumA / NumB;
            return result;
        }
    }

    class OperatorFactory
    {
        public static BaseOperator getOperatorByOp(char op)
        {
            BaseOperator baseOperator = null;

            switch (op)
            {
                case '+':
                    baseOperator = new AddOperator();break;
                case '-':
                    baseOperator = new SubOperator();break;
                case '*':
                    baseOperator = new MulOperator();break;
                case '/':
                    baseOperator = new DivOperator();break;
            }
            return baseOperator;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            int NumA, NumB;
            string op;

            Console.WriteLine("请输入数字A：");
            NumA = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("请输入数字B：");
            NumB = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("请输入符号：");
            op = Console.ReadLine();
            BaseOperator baseOperator = OperatorFactory.getOperatorByOp(op[0]);
            baseOperator.NumA = NumA;
            baseOperator.NumB = NumB;
            Console.WriteLine(baseOperator.GetResult());
            Console.ReadKey();
        }
    }
}

总结：设计模式是为了让代码可扩展、可维护、可复用、灵活性好而创造出来的。简单工厂模式是根据参数的不同返回不同的实例，被创建的实例具有共同的父类。