设计模式学习2——策略模式

结构图

定义

策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。

优点

策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法的公共功能。

同时简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。因此修改任一算法时都不会影响其他的算法。

由于在基本的策略模式中，选择所用具体实现的职责是由客户端对象承担，并转给策略模式的Context对象，因此本身并没有解除客户端需要选择判断的压力，因此可以将策略模式与简单工厂模式结合，将选择具体实现的职责由Context来承担，会最大化减轻客户端的职责。

缺点

要增加一种新的算法时，必须要修改Context中的switch算法，成本较高，可以通过反射的方法来进一步降低成本。

代码实例

用策略模式和简单工厂模式相结合的方法改进计算器。

namespace ConsoleApplication6
{
    //策略类Strategy
    abstract 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;
        }
    }

    //Context类
    class OperationContext
    {
        public Operation op = null;

        public OperationContext(string oper)
        {
            switch (oper)
            {
                case "+":
                    operationAdd oa = new operationAdd();
                    op = oa;
                    break;
                case "-":
                    OperationSub os = new OperationSub();
                    op = os;
                    break;
                case "*":
                    OperationMul om = new OperationMul();
                    op = om;
                    break;
                case "/":
                    OperationDiv od = new OperationDiv();
                    op = od;
                    break;
            }
        }

        public double Getresult()
        {
            return op.Getresult();
        }
    }

    class Program
    {
        static void Main()
        {
            OperationContext oper;
            Console.WriteLine("请输入要进行的运算");
            oper = new OperationContext(Console.ReadLine());
            Console.WriteLine("请输入第一个数字");
            oper.op.numberA = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("请输入第二个数字");
            oper.op.numberB = Convert.ToDouble(Console.ReadLine());
            double result = oper.Getresult();
            Console.WriteLine("结果为：{0}", result);
            Console.ReadLine();
        }
    }
}