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、策略模式 類圖總結

策略模式：定義了算法簇，分別封裝起來，讓它們之間可以互相替換，此模式讓算法的變化獨立於使用算法的客戶

 通過這張類圖可以便於理解和記憶設計模式，后續會把其他模式也分享出自己的學習和理解。