策略模式（从放弃到入门）

时间：2020-12-24 13:30:49

策略模式（来自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图：

策略模式（从放弃到入门）

思考

  1. 感觉用了策略模式，代码量和类增加了不少，但是确实达到了解耦和复用的目的。
  2. 前面的设计并不完美，因为 Duck 类中的接口属性，并没有提供默认值，而是在子类中去完成默认配置。所以在使用时很可能出现 空指针错误，更加完善的设计应该在 performSpeak(), performFly() 中添加非空判断。或者将默认值在 Duck类中设置，子类实现构造方法都不用写了，但是这样把实现和 Duck 耦合在一起，也不是很好。如果有好的解决方案，请留言。
标签：

相关文章