神刀安全网

策略模式(详解)

策略模式(来自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图:

策略模式(详解)
e8559941-b728-470b-9111-63214e6630af.png

思考

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

转载本站任何文章请注明:转载至神刀安全网,谢谢神刀安全网 » 策略模式(详解)

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址