策略模式（Strategy）

先来看一副 Class Diagram

上面这副类图呢，表明，如果您要上学的话，你有四种策略，

您可以走路去，可以坐公交车，可以骑自行车，可以开私家车，

上面的即是一个最简单的策略模式结构图了

先来明白一下聚合关系是什么？

比如 A 对象可以包含 B 对象，但 B 对象不是 A 对象的一部分，则 A 和 B 之间就是一种聚合关系。

比如一个人是属于一个家庭的，而一个家庭可以有多个人，

同时，一个人可以属于多个家庭（自己的家庭，和父母的家庭），

所以人和家庭是聚会关系。

从上面可以很明显的看出，策略和上学是一种聚合关系，

您上学必须要有一个策略（一种上学的方法）才行，而策略（上学的方法）却是独立的，

我走路归走路，和上学没有联系的，是独立的，而上学的话，您必须选一种方式（策略）才能实现。

再来给出策略模式的定义

策略模式定义了算法族，也就是定义了一系列的算法，并分别对这些算法进行了封装，

让这些算法之间可以互换，

这个模式的优点在于，当面对算法经常需要改变时，

这个模式可以让算法的变化独立于使用算法的客户，

也就是说，这个模式可以让算法的变化不会影响到使用算法的客户。

同时由于各个算法类是独立的，从而减少了各种算法类与使用算法类（客户）之间的耦合度。

拿上面的“上学”这个例子来看的话，

我定义了一个策略的基类（一般应定义为抽象类或者是接口），

然后在这个基类下又定义了四个独立的子类，其实，这四个子类就是算法了，

由于四种算法都被封装在了单独的类中，并且都继承自”策略“这个基类，

所以可以让这些算法之间进行互换，由于在客户（也就是“上学”）和算法（策略）之间是聚合关系，

所以这些算法的变化独立于使用算法的客户（上学）。

上面的这幅图就是策略模式的结构图了

下面就完成一个 Demo ，即使用策略模式来完成最开始的“上学”问题：

上面的截图就是关于“上学”问题的具体结构图了，

其中，定义了四个算法，分别计算出上学所要花费的时间，

而在 GoToSchool 中则通过维护一个 StudentStrategy 的实例来获取所需要花费的时间。

先来看策略抽象类 Strategy

namespace Strategy
{
    /// <summary>
    /// 定义抽象算法类（策略抽象类）
    /// </summary>
    abstract public class Strategy
    {
        /// <summary>
        /// 定义一个抽象算法
        /// 其所有的子类必须以自己的方式实现这个方法
        /// </summary>
        /// <returns></returns>
        abstract public double TotalTime();
    }
}

再来看具体策略类 Walk

namespace Strategy
{
    public class Walk:Strategy
    {
        public override double TotalTime()
        {
            return 56.5;
        }
    }
}

具体策略类 Bike

namespace Strategy
{
    public class Bike:Strategy
    {
        public override double TotalTime()
        {
            return 35;
        }
    }
}

具体策略类 Bus

namespace Strategy
{
    public class Bus:Strategy
    {
        public override double TotalTime()
        {
            return 22.5;
        }
    }
}

具体策略类 Sedan

namespace Strategy
{
    public class Sedan:Strategy
    {
        public override double TotalTime()
        {
            return 10;
        }
    }

}

客户类 GoToSchool

namespace Strategy
{
    public class GoToSchool
    {
        //在这个客户类中必须维护一个算法策略对象
        private Strategy strategy;

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

        public double GetTotalTime()
        {
            //利用多态
            return this.strategy.TotalTime();
        }
    }
}

最后就是客户端的 Main 函数咯

using System;
using Strategy;

namespace StrategyTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Strategy.GoToSchool goToSchool = new GoToSchool(new Walk());
            Console.WriteLine("走路所花的时间：{0}", goToSchool.GetTotalTime());

            goToSchool = new GoToSchool(new Bike());
            Console.WriteLine("自行车花的时间：{0}", goToSchool.GetTotalTime());

            goToSchool = new GoToSchool(new Bus());
            Console.WriteLine("公交车花的时间：{0}", goToSchool.GetTotalTime());

            goToSchool = new GoToSchool(new Sedan());
            Console.WriteLine("小轿车花的时间：{0}", goToSchool.GetTotalTime());
            Console.ReadKey();
        }
    }
}

下面就可以给出效果的截图了

从上面的策略模式 Demo 可以看出，我可以在客户端 Main 函数中更改算法，

而客户 GoToSchool 类却并不会受到影响，

甚至它都并不知道，客户端中的算法已经改变了，

同时，也可以看出算法是可以互相替换的，这主要是因为各个算法被封装在了独立的类中，

而这些正是策略模式的优点所在~~~