headfirst設計模式（1）—策略模式

什么是策略模式

策略模式定義了一系列的算法，並將每一個算法封裝起來，而且使它們還可以相互替換。策略模式讓算法獨立於使用它的客戶而獨立變化(摘自百度百科)

關鍵字：算法封裝，相互替換，獨立變化

算法封裝表示，每個算法只提供接口，屏蔽實現的細節。相互替換很好理解，就是有一個共同的父類，當然父類不一定就是class，也可能是interface，這個要根據不同的業務場景來考慮。

獨立變化怎么理解呢？這個就要牽扯到設計原則（我新來的，不知道專業術語是不是這個），對擴展開放，對修改關閉（開閉原則），簡單來說就是，變化的東西放一邊讓它自己慢慢變化，而已經穩定的東西在擴展功能的時候不會產生變化，當然這個是良好的設計。如果加一個功能，然后發現以前的功能各種不能用了，那就太蛋疼了（不要問我怎么知道的，不然我就不會來寫設計模式了）。

在軟件設計中，唯一不變的東西就是：變化。你可能覺得我在扯淡，但是確實是變化，你們的產品經理有沒有天天給你說，昨天那個能不能給我改一下，我覺得這樣更好，balabalabala...,要不然就是，客戶說上次那個功能不行，要再加點東西...，不要問我怎么知道的。

所以為什么要學設計模式呢，為了適應變化，為了少加班，這個是看得見的好處。還有一個好處是，優雅的代碼可以讓強迫症患者心理很舒服。

舉個栗子

某公司有一款模擬鴨子的游戲，具體的表現就是，游戲中有各種鴨子，一邊游泳一邊叫。系統的內部采用的是標准的OO設計。

鴨子的超類如下：

public abstract class Duck {
    public Duck(){
    }
    public abstract void display();
    public void swim(){
        System.out.println("所有的鴨子都會游泳");
    }
    public void quack(){
        System.out.println("所有的鴨子都會呱呱叫");
    }
}

具體實現類如下：

public class MallardDuck extends Duck {
    @Override
    public void display() {
        System.out.println("綠頭鴨，頭是綠色的");
    }
}
public class RedheadDuck extends Duck {
    @Override
    public void display() {
        System.out.println("紅頭鴨，頭是紅色的");
    }
}

其他實現省略....

需求變動：鴨子必須要能飛

簡單的修改

在超類中新增fly方法，讓所有的鴨子都具備飛行的能力

public abstract class Duck {
    //其他方法省略
    public void fly(){
        System.out.println("所有的鴨子都會飛");
    }
}

產生的問題：有的鴨子本身不能飛，但是在Duck類中添加了fly方法，卻錯誤的賦予了它們飛行的能力，比如，橡皮鴨，超類中新加的方法，會影響所有子類的行為。

簡單的解決辦法：最簡單的解決辦法就是利用方法的復寫@Override，復寫fly方法，根據不同鴨子的特性去實現不同的fly。（缺陷：每新加一種鴨子，可能就會去復寫超類的方法，如，加入一只木頭鴨，它可能既不會飛行，又能發出聲音，而且隨着種類越多，那么復寫的次數越多，重復的代碼也就會越多，后期維護的時候可能就需要同時改很多個地方）

設計原則：應用中可能會產生變化之處，要把它們獨立出來，不要和不需要變化的代碼放在一處（不變化的代碼一般是穩定的，加入變化的代碼之后很可能就會破壞原來的穩定性）

 

獨立變化的修改

變化的部分：飛行行為，鳴叫行為

//飛行行為
public interface FlyBehavior {
    void fly();
}
//鳴叫行為
public interface QuackBehavior {
    void quack();
}

Duck超類修改

public abstract class Duck {

    // 接口的權限要根據實際項目來權衡，這里由於子類並不需要關心這兩個接口的作用
    // 全部都交給了父類來調用，所以用private，屏蔽掉細節
    private FlyBehavior flyBehavior;
    private QuackBehavior quackBehavior;
    public abstract void display();
    // 關於構造函數要不要傳入fly行為和quack
    // 這個就要分情況來考慮，如果業務上可以提供默認的行為，那么就可以使用無參的構造函數
    // 如果業務上不能提供默認行為，就可以使用以下注釋中的形式，要求子類強制實現，給后面的開發人員少挖點坑（當然，他們也可以去看以前的代碼）
    public Duck(FlyBehavior flyBehavior, QuackBehavior quackBehavior) {
        this.flyBehavior = flyBehavior;
        this.quackBehavior = quackBehavior;
    }
    // 一般來說，超類的行為是很少會出現變化的(增加或者減少)，如果一直出現變化，就證明這個超類的設計有問題，
    // 或者說壓根就不應該用策略模式，所以上述構造函數一般是不會調整的
    // 在調用過程中一般不要出現下面這種寫法，吞掉錯誤，是一件很蛋疼的事情，會增加隊友們Debug的難度
    //    public void fly() {
    //        if (null == flyBehavior) {
    //            return;
    //        }
    //        flyBehavior.fly();
    //    }
    public void fly() {
        flyBehavior.fly();
    }
    public void quack() {
        quackBehavior.quack();
    }
    public void swim() {
        System.out.println("所有的鴨子默認都會游泳");
    }
    // 加入set方法后就可以隨時調用這兩個方法來改變鴨子的行為（策略模式的精髓，算法之間的相互替換）
    public void setFlyBehavior(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }
    public void setQuackBehavior(QuackBehavior quackBehavior) {
        this.quackBehavior = quackBehavior;
    }
}

Fly接口的實現類

1，不會飛行：

public class FlyNoWay implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("我不會飛行，但是我有夢想");
    }
}

2，用翅膀飛行

public class FlyWithWings implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("我有翅膀，可以飛行");
    }
}

鳴叫行為實現類

1，  呱呱叫

public class Quack implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("呱呱呱....");
    }
}

2，  沉默….

public class MuteQuack implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("........");
    }
}

具體的鴨子類（模型鴨）

public class ModelDuck extends Duck {
    //這里的構造函數有兩種形式
    //第一種帶有飛行行為和鳴叫行為的有參構造函數,這種形式就是完全將行為委托給客戶端，
    //自由度更高，但是客戶端就必須要自己了解所有行為的所有算法,或者他需要用到的所有算法
    //    public ModelDuck(FlyBehavior flyBehavior, QuackBehavior quackBehavior) {
    //        super(flyBehavior, quackBehavior);
    //    }
    //第二種，設置默認的行為，客戶端就不管飛行和鳴叫具體是怎么實現的，只要是模型鴨
    //那么new ModelDuck().fly()，即可.
    //在超類中有setFlyBehavior，setQuakBehavior，同樣允許客戶端自己選擇
    public ModelDuck() {
        super(new FlyNoWay(), new MuteQuack());
    }
    @Override
    public void display() {
        System.out.println("我是一只模型鴨");
    }
}

測試代碼來說明什么是策略模式：

public class Client {
    public static void main(String[] args) {
        Duck duck = new ModelDuck();
        duck.display();
        System.out.println("默認飛行行為:");
        duck.fly();
        System.out.println("默認鳴叫行為:");
        duck.quack();
        //設置新的行為
        duck.setFlyBehavior(new FlyWithWings());
        duck.setQuackBehavior(new Quack());
        System.out.println("新的飛行行為:");
        duck.fly();
        System.out.println("新的鳴叫行為:");
        duck.quack();
        //或者這樣
        duck.setFlyBehavior(new FlyBehavior() {
            @Override
            public void fly() {
                System.out.println("我是火箭飛行模式");
            }
        });
        duck.setQuackBehavior(new QuackBehavior() {
            @Override
            public void quack() {
                System.out.println("學狗叫，汪汪汪");
            }
        });
        System.out.println("自定義的飛行行為:");
        duck.fly();
        System.out.println("自定義的鳴叫行為:");
        duck.quack();
    }
}

現在每只鴨子的叫聲和飛行都可以自己選擇靈活配置，不僅可以切換鴨子，還可以切換鴨子的行為，這在原來的設計上是辦不到的，現在加一種新的鴨子變得很簡單了，而且不會對原來的設計造成影響。

第一次寫東西，寫的比較亂，表達的東西也不一定准確，雖然標題是策略模式，但是bb了很多跟策略模式無關的東西

要是想更清楚的了解策略模式可以去參考這位大神：http://blog.csdn.net/hguisu/article/details/7558249/