策略模式（来自HeadFirst设计模式）
今天看了 Head First 设计模式的第一个模式，居然是策略模式，感觉这种模式很实用，而且书上写了20多页，我这里做一下精简，给大家分享一下，在最后也有一些自己的思考。既然是精简，所以一定会有一些省略，如果要看详细的，看看原书吧，写得很不错！
需求1，父类实现
问题由来
现在要设计一只鸭子类，所有的鸭子都可以游泳，不同的鸭子样外貌可能不一样。
刚拿到这个需求，很简答的想法设计一个Duck类，拥有共有的方法swim，并且包含一个抽象方法display展示形态。
Duck.java
abstract class Duck{
public void swim(){
System.out.println("I am swimming");
}
public abstract void display();
}
GreenDuck.java
public class GreenDuck extends Duck{
@Override
public void display() {
System.out.println("my color is green");
}
}
RedDuck.java
public class RedDuck extends Duck{
@Override
public void display() {
System.out.println("my color is red");
}
}
为什么swim()方法是普通方法，display() 方法是抽象方法呢？
这里是为了体现，所有的都会游泳，并且都一样。所有鸭子都有外貌，但是是由各自决定，所以必须子类来重写。
需求2，接口实现
这时候需求变更，有些鸭子可以飞。
注意，这里的关键词是可以。如果这个时候我们把 fly() 方法写在子类 Duck 中，那就表示所有的鸭子都会飞。所以这个时候我们想到了接口，定义 Flyable 接口，让会飞的鸭子实现接口，并重写方法。
Flyable.java
public interface Flyable {
void fly();
}
GreenDuck.java
public class GreenDuck extends Duck implements Flyable{
public void fly() {
System.out.println("I am flying with wing");
}
@Override
public void display() {
System.out.println("my color is green");
}
}
假设GreenDuck会飞，那么它需要实现flyable接口，然后写自己会飞。RedDuck不会飞，所以不实现flyable接口。
看似问题解决了，但是如果这个时候我们系统中有几十种鸭子，而且会飞只分用翅膀飞，不能飞，用喷气式火箭飞3种，如果采用接口来实现，几十种鸭子都需要自己去实现方法，无法代码重用，这种设计是不是很不好呢，代码重用率太低。
而且，如果后面我们还要添加其他的属性，比如说话Speakable，那我们需要添加一个新接口，并且以前的鸭子都要从新实现一遍，完全违反了开闭原则。
需求3，策略模式实现
关子卖完，我们来看看策略模式怎么实现：
策略模式说，我们需要把最公有的相同的方法放在父类中，将可以变化的方法抽取成接口，并通过组合的方式放到父类中，子类通过插入不同的接口实现，完成类的配置。（这个不是原话，但是我觉得更好理解）
是什么意思呢？
Duck类中，swim() 方法属于共有并且都相同的方法，display() 属于都有，但是需要自己去实现的方法。fly和speak是有些子类有的方法，并且实现有相同有不同，我们应该抽取成接口放在父类中。来看看代码：
修改Duck类：
abstract class Duck{
protected Flyable flyable;
public void swim(){
System.out.println("I am swimming");
}
public abstract void display();
public void performFly(){
// 通过多态机制，动态决定到底怎么飞
flyable.fly();
}
// 设置飞的具体实现，并随时可以改变
public void setFlayable(Flyable flyable){
//TODO:添加非空判断
this.flyable = flyable;
}
}
实现3中飞的行为：
Flyable.java
public interface Flyable {
void fly();
}
FlyNoWay.java 不能飞
public class FlyNoWay implements Flyable{
public void fly() {
System.out.println("can not fly");
}
}
FlyWithWing.java 用翅膀飞
public class FlyWithWing implements Flyable{
public void fly() {
System.out.println("fly with wing");
}
}
FlyWithRocket 用火箭飞（真是掉渣天，居然用火箭飞 -.-）
public class FlyWithRocket implements Flyable{
public void fly() {
System.out.println("fly with rocket");
}
}
如果现在要让 GreenDuck 有飞的属性，应该这样做：
GreenDuck.java
public class GreenDuck extends Duck{
public GreenDuck(){
this.flyable = new FlyNoWay();
}
@Override
public void display() {
System.out.println("my color is green");
}
}
Main.java
public class Main {
public static void main(String[] args) {
GreenDuck gDuck = new GreenDuck();
gDuck.performFly();
gDuck.setFlayable(new FlyWithWing());
gDuck.performFly();
}
}
默认GreenDuck是不会飞的，然后可以通过动态的设置飞属性给鸭子，让他具有各种飞的属性。将飞与类解耦，并且也达到了飞实现重用的目的。
策略模式大概就是这样，如果这个时候我们要添加 Speak 属性，怎么做么？
添加新功能
step1: 添加 Speakable接口，和两种实现
Speakable.java
public interface Speakable {
void speak();
}
SpeakDuckLaguage .java
public class SpeakDuckLaguage implements Speakable {
public void speak() {
System.out.println("I can speak duck language");
}
}
SpeakHumanLaguage.java
public class SpeakHumanLaguage implements Speakable {
public void speak() {
System.out.println("I can speak human language");
}
}
step2: Duck类中添加Speakable属性，并且提供set方法，然后提供一个执行speak的方法
abstract class Duck{
protected Flyable flyable;
protected Speakable speakable;
//...
public void performSpeak(){
speakable.speak();
}
public void setSpeakable(Speakable speakable){
//TODO: 非空判断
this.speakable = speakable;
}
}
step3: 给红鸭子添加会说话属性
RedDuck.java 默认说鸭子语言
public class RedDuck extends Duck{
// 默认说鸭子语言
public RedDuck(){
this.speakable = new SpeakDuckLaguage();
}
@Override
public void display() {
System.out.println("my color is red");
}
}
Main.java 客户端调用
public class Main {
public static void main(String[] args) {
GreenDuck gDuck = new GreenDuck();
gDuck.performFly();
gDuck.setFlayable(new FlyWithWing());
gDuck.performFly();
RedDuck rDuck = new RedDuck();
rDuck.performSpeak();
rDuck.setSpeakable(new SpeakHumanLaguage());
rDuck.performSpeak();
}
}
输出：
I can speak duck language
I can speak human language
can not fly
fly with wing
最后提供一个UML图：
思考
- 感觉用了策略模式，代码量和类增加了不少，但是确实达到了解耦和复用的目的。
- 前面的设计并不完美，因为 Duck 类中的接口属性，并没有提供默认值，而是在子类中去完成默认配置。所以在使用时很可能出现 空指针错误，更加完善的设计应该在 performSpeak(), performFly() 中添加非空判断。或者将默认值在 Duck类中设置，子类实现构造方法都不用写了，但是这样把实现和 Duck 耦合在一起，也不是很好。如果有好的解决方案，请留言。
