【设计模式】之策略模式

• UML

• 原型

    //策略
    abstract class Strategy
    {
        //算法接口
        public abstract void AlgorithmInterface();
    }

     //具体算法A
    class ConcreteStrategyA:Strategy
    {
        public override void AlgorithmInterface()
        {
            Console.WriteLine("策略A");
        }
    }

    //具体算法B
    class ConcreteStrategyB:Strategy
    {
        public override void AlgorithmInterface()
        {
            Console.WriteLine("策略B");
        }
    }

	//具体算法C
    class ConcreteStrategyC:Strategy
    {
        public override void AlgorithmInterface()
        {
            Console.WriteLine("策略C");
        }
    }

    //上下文
    class Context
    {
        Strategy strategy;
        public Context(Strategy strategy)
        {
            this.strategy = strategy;
        }
        //上下文接口
        public void ContextInterface()
        {
            strategy.AlgorithmInterface();
        }
    }

	//主函数
    class Program
    {
        static void Main(string[] args)
        {
            Context context;

            context = new Context(new ConcreteStrategyA());
            context.ContextInterface();

            context = new Context(new ConcreteStrategyB());
            context.ContextInterface();

            context = new Context(new ConcreteStrategyC());
            context.ContextInterface();
        }
    }

• 举例

    //现金收费抽象类
    abstract class CashSuper
    {
        public abstract double acceptCash(double money);
    }

    //正常收费子类
    class CashNormal:CashSuper
    {
        public override double acceptCash(double money)
        {
            return money;
        }
    }

    //打折收费子类
    class CashRebate:CashSuper
    {
        private double moneyRebate = 1d;

        public CashRebate(string moneyRebate)
        {
            this.moneyRebate = double.Parse(moneyRebate);
        }

        public override double acceptCash(double money)
        {
            return money * moneyRebate;
        }
    }

    //返利收费子类
    class CashReturn:CashSuper
    {
        private double moneyCondition = 0.0f;           //返利条件
        private double moneyReturn = 0.0d;              //返利值

        public CashReturn(string moneyCondition,string moneyReturn)
        {
            this.moneyCondition =double.Parse(moneyCondition);
            this.moneyReturn = double.Parse(moneyReturn);
        }

        public override double acceptCash(double money)
        {
            double result = money;
            if(money>=moneyCondition)
            {
                result = money - Math.Floor(money / moneyCondition) * moneyReturn;
            }
            return result;
        }
    }

//上下文
class CashContext
    {
        CashSuper cashSuper;
        public CashContext(string type)
        {
            switch(type)
            {
                case "正常收费":
                    cashSuper = new CashNormal();
                    break;
                case "满300返100":
                    cashSuper = new CashReturn("300", "100");
                    break;
                case "打8折":
                    cashSuper = new CashRebate("0.8");
                    break;
            }
        }

        public double ContextInterface(double money)
        {
            return cashSuper.acceptCash(money);
        }

    }

//主函数
class Program
    {
        static void Main(string[] args)
        {
            CashContext cashContext;

            cashContext = new CashContext("正常收费");
            Console.WriteLine(cashContext.ContextInterface(800d));

            cashContext = new CashContext("满300返100");
            Console.WriteLine(cashContext.ContextInterface(800d));

            cashContext = new CashContext("打8折");
            Console.WriteLine(cashContext.ContextInterface(800d));
        }
    }

• 总结

1. 策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与算法类之间的耦合。
2. 策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为，继承有助于析取出这些算法中的公共功能。
3. 策略模式简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。
4. 当不同的行为堆砌在一个类中时，就很难避免使用条件语句来选择合适的行为，将这些行为封装在一个个独立的strategy类中，可以在使用这些行为的类中消除条件语句。
5. 策略模式就是用来封装算法的，但在实践中，我们发现用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。
6. 在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式的Context对象，而策略模式与简单工厂模式结合后，选择具体实现的职责也可以由Context来承担，最大化减轻了客户端的职责。

(完)