初学设计模式

寒假结束了，新学期开始了。寒假期间刚开始看大话设计模式，虽然感觉书挺厚的，但是书的内容不是那么的枯燥，所以也还是很喜欢看，但是总是看了之后没有什么感觉，虽然可以看懂每个模式，但是似乎如果让自己应用的话还是很困难的，还好师父说看的懂就好，但是对每一种模式有自己的理解就可以。

大概看了几个模式了，想到的就是高中时数学老师说的一句话：一道题有很多种解法，如果你想的多了，那么算的就少，就不容易出错，想的少了，那么算的就多，就容易在计算过程中出错。所以设计模式是为了增强代码的复用性，实现松耦合，实现可扩展性等，所以为了在代码完成后维护过程中，或者在重构时可以更简单方便，在写代码时就要多想想，利用设计模式就可以实现，就拿简单工厂模式来说：

对于计算器的实现最初的代码是：

class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("请输入数字A");
                string strNumberA = Console.ReadLine();
                Console.Write("请选择运算符（+，-,*,/）");
                string strOperate = Console.ReadLine();
                Console.WriteLine("请输入数字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);
            }

        }
    }

如果考虑业务逻辑和界面逻辑分开，降低了耦合度，代码可以添加运算类：

 

public class Operation
    {
        public static double GetResult(double numberA, double numberB, string operate)
        {
            //声明变量result 
            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;
        }
    }

客户端代码可以简化为：

 

static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("请输入数字A");
                string strNumberA = Console.ReadLine();
                Console.Write("请选择运算符（+，-,*,/）");
                string strOperate = Console.ReadLine();
                Console.WriteLine("请输入数字B");
                string strNumberB = Console.ReadLine();
                string strResult = "";
                strResult = Convert.ToString(Convert.ToDouble(strNumberA) + Convert.ToDouble(strNumberB));

                Console.WriteLine("结果是：" + strResult);
                Console.ReadLine();
            }
            catch (Exception ex)
            {
                Console.WriteLine("您输入的又错" + ex.Message);
            }

        }
    }

如果再考虑多态、继承代码则添加运算子类，继承运算类。再利用工厂模式选择要实现的运算

运算类则写为：

 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()
            //声明初始化result
            {
                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("除数不能为零");
                else
                    result = NumberA / NumberB;
                return result;
            }
        }

运算符工厂写为：

 public class OperationFactory
        {
            public static Operation creationOperate(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;
            }
        }

上面的每个代码都是可以实现计算器功能的，但是想的越多，利用的越多，客户端代码就会越简单，越不容易出错，而且代码具有可扩展性和低耦合的特性，所以初学设计模式的感觉就是：虽然代码量会增多，但是对以后维护和修改提供了方便