设计模式之策略模式

策略模式的组成

抽象策略角色： 策略类，通常由一个接口或者抽象类实现。

具体策略角色：包装了相关的算法和行为。

环境角色：持有一个策略类的引用，最终给客户端调用。

策略模式结构图：

 

 

概念

策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

Context(应用场景):

1、需要使用ConcreteStrategy提供的算法。

2、内部维护一个Strategy的实例。

3、负责动态设置运行时Strategy具体的实现算法。

4、负责跟Strategy之间的交互和数据传递。

Strategy(抽象策略类)：

1、 定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，Context使用这个接口调用不同的算法，一般使用接口或抽象类实现。

ConcreteStrategy(具体策略类)：

2、 实现了Strategy定义的接口，提供具体的算法实现。

应用场景

应用场景：

1、 多个类只区别在表现行为不同，可以使用Strategy模式，在运行时动态选择具体要执行的行为。

2、 需要在不同情况下使用不同的策略(算法)，或者策略还可能在未来用其它方式来实现。

3、 对客户隐藏具体策略(算法)的实现细节，彼此完全独立。

优缺点

优点：

1、 提供了一种替代继承的方法，而且既保持了继承的优点(代码重用)还比继承更灵活(算法独立，可以任意扩展)。

2、 避免程序中使用多重条件转移语句，使系统更灵活，并易于扩展。

3、 遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。

缺点：

1、 因为每个具体策略类都会产生一个新类，所以会增加系统需要维护的类的数量。

解决方案：工厂方法

代码示例---商场管理软件

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
/*抽象策略角色： 策略类，通常由一个接口或者抽象类实现。
具体策略角色：包装了相关的算法和行为。
环境角色：持有一个策略类的引用，最终给客户端调用。
http://www.cnblogs.com/beyondchina/archive/2013/04/24/3040845.html */

namespace 策略模式
{
    class Program
    {
        static void Main(string[] args)
        {
            CashContext cashContext = new CashContext("满300返100");

            double totalPrices = 0d;
            //10是单价，５是数量
            totalPrices = cashContext.GetResult(10 * 5);
            Console.WriteLine(totalPrices.ToString());
        }        
    }

    //现金收取工厂
    class CashContext
    {
        CashSuper cs = null;

        //根据条件返回相应的对象
        public CashContext(string type)
        {
            switch (type)
            {
                case "正常收费":
                    CashNormal cs0 = new CashNormal();
                    cs = cs0;
                    break;
                case "满300返100":
                    CashReturn cr1 = new CashReturn("300", "100");
                    cs = cr1;
                    break;
                case "打8折":
                    CashRebate cr2 = new CashRebate(0.8);
                    cs = cr2;
                    break;
            }
        }

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

    //现金收取父类
    public abstract class CashSuper
    {
        //抽象方法：收取现金，参数为原价，返回为当前价
        public abstract double acceptCash(double cash);
    }

    //返利收费,继承CashSuper
    public class CashReturn : CashSuper
    {
        private double moneyCondition = 0.0d;
        private double moneyReturn = 0.0d;

        //初始化时必须要输入返利条件和返利值，比如满300返100,则moneyCondition为300, moneyReturn为100
        public CashReturn(string moneyCondition, string moneyReturn)
        {
            this.moneyCondition = double.Parse(moneyCondition);
            this.moneyReturn = double.Parse(moneyReturn);
        }

        //返利类
        public override double acceptCash(double cash)
        {
            double result = cash;

            //若大于反复条件，则需要减去返利
            if (cash >= moneyCondition)
                result = cash - Math.Floor(cash / moneyCondition) * moneyReturn;

            return result;
        }
    }

    //打折收费, 继承CashSuper
    public class CashRebate : CashSuper
    {
        private double moneyRebate = 1d;
        //初始化时，必需输入折扣率，如８折，就0.8
        public CashRebate(double moneyRebate)
        {
            this.moneyRebate = moneyRebate;
        }

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

    //正常收费，继承CashSuper
    public class CashNormal : CashSuper
    {
        public override double acceptCash(double cash)
        {
            return cash;
        }
    }
}