面向对象编程，并不类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象类集合才是类。

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

 

 

abstract class CashSuper
    {
        /// <summary>
        /// The algorithm
        /// </summary>
        public abstract double AcceptCash(double money);
    }

 

class CashNormal : CashSuper
    {
        public override double AcceptCash(double money)
        {
            return money;
        }
    }

 

 class CashRebate : CashSuper
    {
        private double moneyRerate = 1d;

        public CashRebate(double moneyRerate)
        {
            this.moneyRerate = moneyRerate;
        }

        public override double AcceptCash(double money)
        {
            return money * moneyRerate;
        }
    }

 

 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)
        {
            double result = money;
            if (money >= moneyCondition)
                result = money - Math.Floor(money / moneyCondition) * moneyReturn;
            return result;
        }
    }

 

public class CashContext
    {
        private CashSuper cs = null;

        public CashContext(string type)
        {
            switch (type)
            { 
                case "正常收费":
                    CashNormal cn = new CashNormal();
                    cs = cn;
                    break;
                case "满300返100":
                    CashReturn cr = new CashReturn(300, 100);
                    cs = cr;
                    break;
                case "打8折":
                    CashRebate cre = new CashRebate(0.8);
                    cs = cre;
                    break;
            }
        }

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

 客户端调用:

            double total = 0.0d;
            Console.WriteLine("请输入收费类型：");
            string type = Console.ReadLine();
            CashContext cc = new CashContext(type);
            double money = 0.0d;
            double price = 0.0d;
            int number = 0;
            Console.WriteLine("请输入商品单价：");
            double.TryParse(Console.ReadLine().ToString(), out price);
            Console.WriteLine("请输入商品数量：");
            int.TryParse(Console.ReadLine().ToString(), out number);
            money = price * number;
            total = cc.GetResult(money);
            Console.WriteLine(string.Format("合计为：{0}", total));

策略模式解析:

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

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

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

当不同的行为堆砌在一个类中时,就很难避免使用条件语句来选择合适的行为.将这些行为封装在一个个独立的Strategy类中,可以使这些行为类中消除条件语句.

在实践中,我们可以发现封装任何类型的规则,只要在分析过程中听到需要在不同时间应用不同的业务规则,就可以考虑使用策略模式处理这种变化.