Head First设计模式——策略模式

1、继承带来的扩展和复用问题

继承作为面向对象的三大要素(封装、继承、多态)之一为什么会带来问题，问题如何解决然后形成一种设计模式，head frist设计模式书中以鸭子作为例子讲解什么情况下继承的方式会带来问题。首先有各种各样的鸭子，那么自然想到各种鸭子继承自一个父类：父类为Duck，现有绿头鸭GreenHeadDuck和红头鸭RedHeadDuck

public abstract Class Duck{
　　public void quack(){}
　　public void swin(){}
　　public abstract void display();
}

publci class GreenHeadDuck:Duck{
    public overrid void  display(){
      //外观绿头
    }
}

publci class ReadHeadDuck:Duck{
    public overrid void  display(){
      //外观红头
    }
}

父类中所有鸭子都会呱呱叫(quack)和游泳(swin)，外观却不一样所以display为抽象方法，让继承它的子类重写。现在需要新增一种鸭子，但这个鸭子是一个玩具橡皮鸭，我们按照继承的方式则橡皮鸭实现代码如下

publci class RubberDuck:Duck{
  　public override void qucak(){
　　　　//覆盖成吱吱吱叫
　　}
    public override void  display(){
      //外观是橡皮鸭
    }
}

　　

因为橡皮鸭是不会像其他鸭子那样叫的，所以上面代码我们需要重写qucak覆盖橡皮鸭叫的方式可。现在有一个需求，需要让鸭子飞起来，按照继承的方式我们给父类Duck添加 fly方法即可让所有鸭子飞起来。但是问题出现了，橡皮鸭是不会飞的，于是我们可以像覆盖qucak方法一样在RubberDuck中覆盖fly方法。

public abstract class Duck{
　　public void quack(){}
　　public void swin(){}
　　public abstract void display();
    public void fly(){}
}

publci class RubberDuck:Duck{
　　public override void qucak(){
　　　　//覆盖成吱吱吱叫
　　}
    public override void  display(){
      //外观是橡皮鸭
    }
    public override void fly(){
        //覆盖，什么都不做
    }
}

到这里我们已经发现了继承带来的问题：

1、代码在多个子类中重复。

2、很难知道所有子类的行为。

3、运行的子类行为不容易改变。

4、改变会牵一发动全身，引起其他子类不想要的改变。

每当有新的子类出现，就要检查是不是需要覆盖父类方法。比如再加一种木头玩具的鸭子(DecoyDuck)，那么木头鸭子不会叫也不会飞，我们是不是需要覆盖叫和飞的方法。

2、进一步的改进，利用接口

　　由于quack和fly有可能变化，所以我们将quack 和fly抽象成接口，能够叫和飞行的鸭子才按需求继承接口自己实现方法。

利用接口可以解决一部分问题(不在需要重写不需要的方法)，但是却会造成代码无法复用，因为接口不具有实现，我们要在每种子类中写fly和quack。比如要在红头绿头中写"呱呱叫"，要在橡皮鸭中写"吱吱叫"。

3、进一步改进，策略模式

经过上面的分析可以引出设计模式的两个原则

1、把会变化的部分封装起来，让其他部分不会受到影响。

2、针对接口编程，而不是针对实现。

通过第一个设计原则我们可以取出易于变化的部分：鸭子的飞行行为(fly)和呱呱叫的行为(quack)。通过第二个设计原则我们知道需要利用接口代表每个行为，比如FlyBehavior与QuackBehavior,而行为的每个实现都将实现其中的一个接口。这样鸭子类就不会负责实现FlyBehavior与QuackBehavior，而是由行为类来专门实现，不会绑死在鸭子的子类中。

而"针对接口编程"的意思是"针对超类型编程"。可以明确地说明变量的声明类型应该是超类，这意味着我们在Duck父类中声明的行为变量为 FlyBehavior，QuackBehavior，"针对接口编程"的关键就在于面向对象三要素之一的"多态"，由于多态我们才能在调用超类的方法时执行的是实现类或子类的方法。所以我们改造之前写的Duck类，删除Fly()和Quack()，加入FlyBehavior和QuackBehavior变量，并用另外两个方法PerFormFly()和PerFormQuack()来执行两个行为。

public abstract Class Duck{
    protected FlyBehavior flyBehavior;
    protected QuackBehavior quackBehavior;

　　public void swin(){}
　　public abstract void display()；
   public void PerFormFly(){
      flyBehavior.fly();
   }
　　public void PerFormQuack(){
      quackBehavior.quack();
   }
}

编写相关类并测试：

     //封装飞行行为
     public interface FlyBehavior
     {
         public void fly();
     }

     public class FlyWithWings : FlyBehavior
     {
         public void fly()
         {
             Console.WriteLine("用翅膀飞");
         }
     }
     public class FlyNoWay : FlyBehavior
     {
         public void fly()
         {
             Console.WriteLine("不飞，什么也不做");
         }
     }

     //封装叫声行为
     public interface QuackBehavior
     {
        public void quack();
     }

     public class Quack : QuackBehavior
     {
         public void quack()
         {
             Console.WriteLine("呱呱叫");
         }
     }
     public class Squack : QuackBehavior
     {
         public void quack()
         {
             Console.WriteLine("吱吱叫");
         }
     }
     public class MuteQuack : QuackBehavior
     {
         public void quack()
         {
             Console.WriteLine("不会叫");
         }
     }

     /// <summary>
     /// 鸭子超类
     /// </summary>
     public abstract class Duck {

         protected FlyBehavior flyBehavior;
         protected QuackBehavior quackBehavior;

         public void swin() { }
         public abstract void display();
         public void PerFormFly()
         {
             flyBehavior.fly();
         }
         public void PerFormQuack()
         {
             quackBehavior.quack();
         }
     }

     /// <summary>
     /// 绿头鸭
     /// </summary>
     public class GreenHeadDuck : Duck
     {
         public GreenHeadDuck() {
             flyBehavior = new FlyWithWings();
             quackBehavior = new Quack();
         }
         public override void display()
         {
             Console.WriteLine("绿头鸭,我的头顶有一片草原(*^_^*)");
         }
     }

     /// <summary>
     /// 橡皮鸭
     /// </summary>
     public class RubberDuck : Duck
     {
         public RubberDuck()
         {
             flyBehavior = new FlyNoWay();
             quackBehavior = new Squack();
         }
         public override void display()
         {
             Console.WriteLine("橡皮鸭");
         }
     }

         static void Main(string[] args)
         {
             //绿头鸭
             Duck greenHeadDuck = new GreenHeadDuck();
             greenHeadDuck.display();
             greenHeadDuck.PerFormQuack();
             greenHeadDuck.PerFormFly();
             Console.WriteLine("--------------------------");
             //橡皮鸭
             Duck rubberDuck = new RubberDuck();
             rubberDuck.display();
             rubberDuck.PerFormQuack();
             rubberDuck.PerFormFly();
             Console.ReadKey();
         }

如上测试我们在鸭子子类中通过构造方法实例化行为类，但建立了一堆动态的功能没有用到，是否可以动态的设定行为而不是在构造函数里面实例化。所以我们还可以加入两个设置行为的方法 SetFlyBehavior和SetQuackBehavior，再次测试动态设定行为。

    /// <summary>
    /// 鸭子超类
    /// </summary>
    public abstract class Duck {

        protected FlyBehavior flyBehavior;
        protected QuackBehavior quackBehavior;

        public void swin() { }
        public abstract void display();

        public void SetFlyBehavior(FlyBehavior flyBehavior) {
            this.flyBehavior = flyBehavior;
        }

        public void SetQuackBehavior(QuackBehavior quackBehavior) {
            this.quackBehavior = quackBehavior;
        }
        public void PerFormFly()
        {
            flyBehavior.fly();
        }
        public void PerFormQuack()
        {
            quackBehavior.quack();
        }
    }

　　

4、策略模式 类图总结

策略模式：定义了算法簇，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户

通过这张类图可以便于理解和记忆设计模式，后续会把其他模式也分享出自己的学习和理解。