设计模式——策略模式

转载请注明出处！

策略模式说明：它定义了算法家族，分别封装起来，让它们之间可以相互替换。此模式让算法的变化，不会影响到使用算法的用户

话不多说，直接上模版代码：

//上下文，维护对Strategy对象的引用
    class Context
    {
        Strategy strategy;

        public Context(Strategy strategy)
        {
            this.strategy = strategy;
        }

        //上下文接口
        public void ContextInterface()
        {
            strategy.AlgorithmInterface();
        }

    }

//抽象算法类，定义了所有支持的算法接口
    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 MainProgram
    {
        
        public static void Main(string[] arg)
        {
            //实例化不同的策略
            Context context;
            context = new Context(new ConcreteStrategyA());
            context.ContextInterface();

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

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

            Console.ReadKey();
        }

    }

运行结果：

 

下面举例应用策略模式，在商场收银系统的应用。

一个商场有多种收费策略，例如正常收费、打折收费、满300减100等。还是继续上代码：

//上下文
    class CashContext
    {
        CashSuper cashSuper = null; 

        //将实例化具体策略的过程由客户端转移到Context类中，是简单工厂的应用
        public CashContext(int num)
        {
            switch (num)
            {
                case 1:   //正常收费
                    cashSuper = new CashNormal();
                    break;
                case 2:   //八五折
                    cashSuper = new CashRebate("0.85");
                    break;
                case 3:   //满300减100
                    cashSuper = new CashReturn(300, 100);
                    break;
                default:
                    return;
            }
        }

        //返回应收金额
        public double GetResult(double money)
        {
            return cashSuper.acceptCash(money);
        }

    }

 //现金收费抽象类
    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 Rebate = 1;   //折扣

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

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

 //返利收费子类
    class CashReturn : CashSuper
    {
        private double MoneyCondition = 0.0d;    //返利条件
        private double MoneyReturn = 0.0d;  //返利数量

        public CashReturn(double MoneyCondition, double MoneyReturn)
        {
            this.MoneyCondition = MoneyCondition;
            this.MoneyReturn = MoneyReturn;
        }

        //算法具体实现
        public override double acceptCash(double money)
        {
            if (money >= MoneyCondition)
                return money - Math.Floor(money / MoneyCondition) * MoneyReturn;
            return money;
        }
    }

//客户端代码
class Program
    {
        static void Main(string[] args)
        {
            int index = 0;
            while(index < 1 || index > 3)
            {
                Console.WriteLine("1、不优惠；");
                Console.WriteLine("2、八五折优惠；");
                Console.WriteLine("3、满300减100；");
                Console.Write("请选择优惠方式：");
                string num = Console.ReadLine();

                if(!int.TryParse(num, out index))
                {
                    index = 0;
                }
            }

            double money = 0;
            while(money <= 0)
            {
                Console.Write("请输入总金额：");
                string count = Console.ReadLine();

                if(!double.TryParse(count, out money))
                {
                    money = 0;
                }
            }

            CashContext context = new CashContext(index);
            Console.WriteLine("应收金额：" + context.GetResult(money));
            
            Console.ReadKey();
        }
    }

策略模式就是用来封装算法的，但是在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中发现需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。