【设计模式】策略模式

策略模式（Strategy） 

   定义了算法家族，分别封装起来，让它们之间的相互替换，此模式让算法的变化，不会影响使用算法的客户。它定义一系列算法或行为的方法，所有算法都完成相同工作，只是实现不同，可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合，运用了继承的方法。它就是用来封装算法的，但实际上可以用它封装几乎任何类型的规则，之哟啊在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理。

 /// <summary>
    /// 现金收费抽象类
    /// </summary>
    abstract class CashSuper
    {
        public abstract double acceptCash(double money);    //现金收取超类的抽象方法，收取现金，参数为原价，返回当前价
    }

    /// <summary>
    /// 正常收费子类
    /// </summary>
    class CashNormal : CashSuper
    {
        public override double acceptCash(double money)
        {
            return money;        //正常收费，原价返回
        }
    }

    /// <summary>
    /// 打折收费子类
    /// </summary>
    class CashRebate : CashSuper
    {
        private double moneyRedate = 1d;
        public CashRebate(string moneyRedate)
        {
            this.moneyRedate = double.Parse(moneyRedate);  //打折收费，初始化时，必需要输入折扣率
        }

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

    /// <summary>
    /// 返利收费子类
    /// </summary>
    class CashReturn : CashSuper
    {
        private double moneyCondition = 0.0d;
        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;
        }
    }

    /// <summary>
    /// 现金收费工厂类
    /// </summary>
    class CashFactory
    {
        public static CashSuper createCashAccept(string type)    //现金收取工厂
        {
            CashSuper cs = null;
            switch (type)        //根据条件返回相应的对象
            {
                case "正常收费":
                    cs = new CashNormal();
                    break;
                case "满300返100":
                    CashReturn cr1 = new CashReturn("300", "100");
                    cs = cs1;
                    break;
                case "打8折":
                    CashRebate cs2 = new CashRebate("0.8");
                    cs = cs2;
                    break;
            }
            return cs;
        }
    }

    /// <summary>
    /// 对抽象类的引用
    /// </summary>
    class CashContext
    {
        CashSuper cs = null;  //生命一个CashSuper对象
        public CashContext(string type)     //注意参数不是具体的收费策略对象，而是一个字符串，表示收费类型
        {
            switch (type)           //实例化具体策略的过程，简单工厂的应用
            {
                case "正常收费":
                    CashNormal cs0 = new CashNormal();
                    cs = cs0;
                    break;
                case "满300，返100":
                    CashReturn cs1 = new CashReturn("300", "100");
                    cs = cs1;
                    break;
                case "打8折":
                    CashRebate cs2 = new CashRebate("0.8");
                    cs = cs2;
                    break;
            }
        }

        public double GetResult(double money)
        {
            return cs.acceptCash(money);
        }
    }

 

  优点就是简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试

 

  缺点是在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式的Context对象，此并没有接触客户端需要选择判断的压力，因此需要与简单工厂模式结合，选择具体实现的职责也可以有Context来承贷，这最大化地减轻了客户端的职责。