Strategy 策略模式

策略模式：定义一系列的算法，把他们一个个封装起来，并且使它们可以相互替换，。本模式使得算法可以独立于使用它的客户而变化。

故事背景：开发一款鸭子模拟游戏，游戏中会出现各种鸭子，一边游泳，一边嘎嘎叫。此系统的内部使用了标准的OO技术，设计了一个鸭子基类，并让各种鸭子继承此基类。基类中有Speak()方法，Swim()方法，还有一个虚方法Display()。3个子类WhiteDuck,BlackDuck,RubberDuck

代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StrategyPattern
{
   public  class Duck
    {
        protected string name = "duck";
        public Duck()
        {

        }
        public Duck(string name)
        {
            this.name = name;
        }
        public void Quack()
        {
            Console.WriteLine(name + "鸭子在嘎嘎叫");
        }
        public void Swim()
        {
            Console.WriteLine(name + "鸭子在游泳");
        }

        public virtual void Display()
        {
            Console.WriteLine(name + "基类的display方法被调用");
        }
        public void Fly()
        {
            Console.WriteLine(name + "鸭子在飞");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StrategyPattern
{
    class RedDuck :Duck
    {
        public RedDuck()
        {

        }
        public RedDuck(string name):base(name)
        {

        }
        public override void Display()
        {
         
            Console.WriteLine(name + "红头鸭子");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StrategyPattern
{
    class GreenDuck:Duck
    {
        public GreenDuck()
        {

        }
        public GreenDuck(string name):base(name)
        {

        }
        public override void Display()
        {
            Console.WriteLine(name + "绿头鸭子");
        }
    }
}

using System;

namespace StrategyPattern
{
    class RubberDuck:Duck
    {
        public RubberDuck()
        {

        }
        public RubberDuck(string name):base(name)
        {
            
        }

        public override void Display()
        {
            Console.WriteLine(name + "橡皮鸭子");
        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StrategyPattern
{
    class Client
    {
        static void Main(string[] args)
        {
            Duck redDuck = new RedDuck("Mr.Red");
            redDuck.Display();
            redDuck.Quack();
            redDuck.Swim();

            Duck greenDuck = new GreenDuck("Mr.Green");
            greenDuck.Display();
            greenDuck.Quack();
            greenDuck.Swim();

            Duck rubberDuck = new RubberDuck("Mr.Rubber");
            rubberDuck.Display();
            rubberDuck.Quack();
            rubberDuck.Swim();

            Console.ReadKey();
        }
    }
}

运行结果：

新的需求：现在需要会飞的鸭子

实现：只要在基类中新加一个Fly()方法，然后在客户端调用就可以了。真的是这样么？如果这样做，你会RubberDuck在飞（注：rubber 橡皮），这可不是我们想要的结果。

要想解决这个办法很简单，在RubberDuck中定义一个同名函数隐藏基类中的同名方法Fly，然后什么都不做就行了。或者把Fly设计成一个虚方法，同样在子类中覆盖，什么都不做就行了。

新的需求：需要诱饵鸭子，既不会飞，也不会叫。解决这个问题的方法也很简单，在定义一个子类DecoyDuck,覆盖子类的Fly和Speak方法就行了，同样方法体为空。

思考：利用继承来提供Duck的行为导致的缺点：

1.运行时的行为不容易改变

2.改变会牵一发而动全身，造成其他鸭子不想要的改变。

3.代码在多个子类中重复

4.很难直到所有鸭子的全部行为。

策略模式大显身手：

把行为与Duck分离出来，定义两个接口QuackBehaviour和FlyBehaviour。定义两个实现QuackBehaviour的类：QuackLoudly和QuackMute。定义两个实现FlyB ehaviour的类：FlyWithWings和FlyNoway。

Duck中删除Fly和Quack方法，添加PerformQuack和PerformFly方法。要想获得叫和飞的行为只要获得飞和叫的类就可以了，让飞和叫的类取实现这些功能。因此需要在Duck中添加两个接口的引用：

QuackBehaviour quackBehaviour 和 FlyBehaviour flyBehaviour。获得引用还不行，还需要获得实例。因此再添加2个方法：SetQuackBehaviour(QuackBehaviour qb) 和 SetFlyBehaviour(FlyBehaviour fb);

具体代码如下，2个具体的鸭子类就可已说明问题了，偷懒起见GreenDuck就不测试了。

using System;
namespace StrategyPattern
{
    public interface FlyBehaviour
    {
         void Fly();
    }
    public class FlyWithWings : FlyBehaviour
    {
       public void Fly()
        {
            Console.WriteLine("我会飞");
        }
    }
    public class FlyNoWay:FlyBehaviour
    {
        public void Fly()
        {
            Console.WriteLine("我不会飞");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StrategyPattern
{
    public interface QuackBehaviour
    {
        void Quack();
    }

    public class QuackLoudly:QuackBehaviour
    {
        public void Quack()
        {
            Console.WriteLine(("嘎嘎叫"));
        }
    }
    public class QuackMute:QuackBehaviour
    {
        public void Quack()
        {
            Console.WriteLine("不会叫");
        }
           
    }
}

using System;

namespace StrategyPattern
{
    public  class Duck
    {
        public FlyBehaviour flyBehaviour;
        public QuackBehaviour quackBehaviour;
        protected string name = "duck";
        public Duck()
        {

        }
        public Duck(string name)
        {
            this.name = name;
        }
        public void SetFlyBehaviuor(FlyBehaviour fb)
        {
            flyBehaviour = fb;
        }
        public void SetQuackBehaviour(QuackBehaviour qb)
        {
            quackBehaviour = qb;
        }
       
        public void Swim()
        {
            Console.WriteLine(name + "鸭子在游泳");
        }
        public void PerformQuack()
        {
            Console.WriteLine(("I am" + name));
            quackBehaviour.Quack();
        }
        public virtual void Display()
        {
            Console.WriteLine(name + "基类的display方法被调用");
        }
       public  void PerformFly()
        {
            Console.WriteLine(("I am" + name));
            flyBehaviour.Fly();
        }
    }
}

测试类Client.

using System;

namespace StrategyPattern
{
    class Client
    {
        static void Main(string[] args)
        {
            FlyBehaviour flyBehaviour = new FlyWithWings();         //定义一个会飞的行为
            FlyBehaviour notFlyBehaviour = new FlyNoWay();          //定义一个不会飞的行为
            QuackBehaviour quackBehaviour = new QuackLoudly();      //定义一个嘎嘎叫的行为
            QuackBehaviour notQuackBehaviour = new QuackMute();     //定义以一个不会叫的行为

            Duck redDuck = new RedDuck("Mr.Red");
            redDuck.SetFlyBehaviuor(flyBehaviour);                  //动态添加飞行行为
            redDuck.PerformFly();
            redDuck.SetQuackBehaviour(quackBehaviour);                  //动态添加嘎嘎叫行为
            redDuck.PerformQuack();

           

            Duck rubberDuck = new RubberDuck("Mr.Rubber");
            rubberDuck.SetFlyBehaviuor(notFlyBehaviour);
            rubberDuck.PerformFly();
            rubberDuck.SetQuackBehaviour(notQuackBehaviour);
            rubberDuck.PerformQuack();

            Console.ReadKey();
        }
    }
}

参考资料：《Head First 设计模式》