您现在的位置是：首页 >其他 >设计模式之策略模式网站首页其他
设计模式之策略模式
简介设计模式之策略模式
1、场景推导
King上班的公司做了一套相当成功的模拟鸭子游戏：SimUDuck。
游戏中会出现各种鸭子，一边游泳戏水，一边呱呱叫。
此系统的内部设计使用了标准的OO技术，设计了一个鸭子超类，并让各种鸭子继承此超类
我们看一下UML 类图
abstract class Duck {
public void quack() {
System.out.println("呱呱叫");
}
public void swim() {
System.out.println("游泳");
}
// 因为每一种鸭子的外观都不同，所以display（）方法是抽象的
public abstract void display();
}
// 野鸭子
class MallardDuck extends Duck {
@Override
public void display() {
System.out.println("外观是绿头");
}
}
//红头鸭
class RedHeadDuck extends Duck {
@Override
public void display() {
System.out.println("外观是红头");
}
}
public class StrategyApp{
public static void main(String[] args) {
Duck duck = new MallardDuck();
duck.quack();
duck.swim();
duck.display();
System.out.println("=========================================");
duck = new RedHeadDuck();
duck.quack();
duck.swim();
duck.display();
/**
* 呱呱叫
* 游泳
* 外观是绿头
* =========================================
* 呱呱叫
* 游泳
* 外观是红头
*/
}
}
程序没啥毛病，过了一段时间…
主管们决定，此模拟程序需要会飞的鸭子来将竞争者抛在后头。当然，在这个时候，King的经理拍胸脯告诉主管们，
King只需要一个星期就可以搞定。“毕竟，King是一个OO程序员…这有什么困难？？”
King认为，只需要在Duck类中加上fly()方法，然后所有鸭子都会继承fly()。
“这是我大显身手，展示OO才华的时候了！” King上来就是梭哈搞定，打完收工~
abstract class Duck {
public void quack() {
System.out.println("呱呱叫");
}
public void swim() {
System.out.println("游泳");
}
public void fly() {
System.out.println("真的飞起来了!");
}
// 因为每一种鸭子的外观都不同，所以display（）方法是抽象的
public abstract void display();
}
//野鸭子
class MallardDuck extends Duck {
@Override
public void display() {
System.out.println("外观是绿头");
}
}
//红头鸭
class RedHeadDuck extends Duck {
@Override
public void display() {
System.out.println("外观是红头");
}
}
//橡皮鸭
class RubberDuck extends Duck {
// 橡皮鸭子不会呱呱叫，所以把quack()的定义覆盖成“吱吱叫”
@Override
public void quack() {
System.out.println("吱吱叫");
}
@Override
public void display() {
System.out.println("外观是橡皮鸭");
}
}
public class StrategyApp {
public static void main(String[] args) {
//向上转型
Duck duck = new MallardDuck();
duck.quack();
duck.swim();
duck.fly();
duck.display();
System.out.println("=========================================");
duck = new RedHeadDuck();
duck.quack();
duck.swim();
duck.fly();
duck.display();
System.out.println("=========================================");
duck = new RubberDuck();
duck.quack();
duck.swim();
duck.fly(); // 橡皮鸭飞起来了！？
duck.display();
}
/**
* 呱呱叫
* 游泳
* 真的飞起来了!
* 外观是绿头
* =========================================
* 呱呱叫
* 游泳
* 真的飞起来了!
* 外观是红头
* =========================================
* 吱吱叫
* 游泳
* 真的飞起来了! //橡皮鸭飞起来了，这合理吗？
* 外观是橡皮鸭
*
* 进程已结束,退出代码0
*/
}
问题似乎解决了
噢？ 是吗？真的是这样吗?
King没有想到，在众多的Duck子类中，有了一个RubberDuck（橡皮鸭）
king忽略了一件事，并非Duck的所有子类都会飞。king在Duck超类中加上新的行为， 会使得某些并不适合该行为的子类也具有该行为。
现在可好了！SimUDuck程序中有了 一个无生命的会飞的东西。
针对于上面的问题，King的解决方法是这样的：我可以把橡皮鸭类中的fly()方法覆盖掉，就好像覆盖quack()的做法一样
abstract class Duck {
public void quack() {
System.out.println("呱呱叫");
}
public void swim() {
System.out.println("游泳");
}
public void fly() {
System.out.println("真的飞起来了!");
}
// 因为每一种鸭子的外观都不同，所以display（）方法是抽象的
public abstract void display();
}
//野鸭子
class MallardDuck extends Duck {
@Override
public void display() {
System.out.println("外观是绿头");
}
}
//红头鸭
class RedHeadDuck extends Duck {
@Override
public void display() {
System.out.println("外观是红头");
}
}
//橡皮鸭
class RubberDuck extends Duck {
// 橡皮鸭子不会呱呱叫，所以把quack()的定义覆盖成“吱吱叫”
@Override
public void quack() {
System.out.println("吱吱叫");
}
@Override
public void display() {
System.out.println("外观是橡皮鸭");
}
// 橡皮鸭子不会飞，所以把fly()覆盖为什么事都不做，或者抛出一个UnsupportedOperationException
@Override
public void fly() {
throw new UnsupportedOperationException("you can you up, no can no bb!");
}
}
public class StrategyApp {
public static void main(String[] args) {
Duck duck = new MallardDuck();
duck.quack();
duck.swim();
duck.fly();
duck.display();
System.out.println("=========================================");
duck = new RedHeadDuck();
duck.quack();
duck.swim();
duck.fly();
duck.display();
System.out.println("=========================================");
duck = new RubberDuck();
duck.quack();
duck.swim();
duck.fly();
duck.display();
}
/**
* 呱呱叫
* 游泳
* 真的飞起来了!
* 外观是绿头
* =========================================
* 呱呱叫
* 游泳
* 真的飞起来了!
* 外观是红头
* =========================================
* 吱吱叫
* 游泳
* Exception in thread "main" java.lang.UnsupportedOperationException: you can you up, no can no bb!
* at com.hh.demo.p_strategy.c.RubberDuck.fly(Test.java:47)
* at com.hh.demo.p_strategy.c.Test.main(Test.java:73)
*
* 进程已结束,退出代码1
*/
}
这样做，橡皮鸭就不会让人意外地飞起来了！ 如果客户端非要让一个橡皮鸭飞，只会收到一个运行时异常!
可是，如果以后加入木鸭（WoodenDuck），又会如何？？木头假鸭，不会飞也不会叫… King只能表示要疯了！！！
class WoodenDuck extends Duck {
@Override
public void quack() {
// 覆盖，变成什么事都不做
}
@Override
public void display() {
System.out.println("外观是木鸭");
}
@Override
public void fly() {
// 覆盖，变成什么事都不做
}
}
我们来看看利用继承来提供Duck的行为，会导致:
-
很难知道所有鸭子的全部行为。
-
改变会牵一发而动全身，造成其他鸭子不想要的改变。
-
更糟糕的是，每当有新鸭子 子类出现，King就要被迫检查并可能覆盖fly()或quack()方法…
这简直是无穷无尽的噩梦!
我们需要一个更清晰的方法，让“某些”（而不是全部）鸭子类型可飞或可叫
通过前面的学习，我们知道：把主要功能定义在父类中，把扩展功能定义在接口中。
从目前这个状况来看，“游泳“是鸭子的主要功能，飞”和“呱呱叫”成为了鸭子的扩展功能，因为并不是所有的鸭子都会“飞”和“呱呱叫”，但是所有的鸭子都会游泳吧，这时杠精又说了，橡皮鸭和木鸭没有生命，怎么会游泳呢？
我直接好家伙！！！
解决方案
King的解决之道是：
我可以把fly()从超类中取出来，放进一个“Flyable接口”中。这么一来，只有会飞的鸭子才实现此接口。
同样的方式，也可以用来设计一个“Quackable”接口，因为不是所有的鸭子都会叫。
看一下UML 类图
abstract class Duck {
public void swim() {
System.out.println("游泳");
}
public abstract void display();
}
//飞
interface Flyable {
public void fly();
}
//叫
interface Quackable {
public void quack();
}
//野鸭子
class MallardDuck extends Duck implements Flyable, Quackable {
@Override
public void quack() {
System.out.println("嘎嘎叫");
}
@Override
public void fly() {
System.out.println("飞起来了");
}
@Override
public void display() {
System.out.println("外观是绿头鸭");
}
}
//红头鸭
class RedheadDuck extends Duck implements Flyable, Quackable {
@Override
public void quack() {
System.out.println("嘎嘎叫");
}
@Override
public void fly() {
System.out.println("飞起来了");
}
@Override
public void display() {
System.out.println("外观是红头鸭");
}
}
//橡皮鸭
class RubberDuck extends Duck implements Quackable {
@Override
public void quack() {
System.out.println("嘎嘎叫");
}
@Override
public void display() {
System.out.println("外观是橡皮鸭");
}
}
//木鸭子
class WoodenDuck extends Duck {
@Override
public void display() {
System.out.println("外观是木头假鸭");
}
}
public class StrategyApp {
public static void main(String[] args) {
MallardDuck duck = new MallardDuck();
duck.quack();
duck.swim();
duck.fly();
duck.display();
System.out.println("=========================================");
RedheadDuck duck2= new RedheadDuck();
duck2.quack();
duck2.fly();
duck2.swim();
duck2.display();
System.out.println("=========================================");
RubberDuck duck3 = new RubberDuck();
duck3.quack();
duck3.swim();
duck3.display();
}
/**
* 嘎嘎叫
* 游泳
* 飞起来了
* 外观是绿头鸭
* =========================================
* 嘎嘎叫
* 飞起来了
* 游泳
* 外观是红头鸭
* =========================================
* 嘎嘎叫
* 游泳
* 外观是橡皮鸭
*
* 进程已结束,退出代码0
*/
}
我们知道，并非“所有”的子类都具有飞和呱呱叫的行为，所以继承并不是恰当的解决方式。
虽然Flyable与Quackable可以解决“一部分”问题（不会再有会飞的橡皮鸭），但是却造成代码无法复用（fly和quack），这只能算是从一个恶梦跳进另一个恶梦。
甚至，在会飞的鸭子中，飞行的动作可能还有多种变化…
也许你会说，自jdk1.8开始，接口有默认实现。
那么对于48种鸭子的子类，共有12种飞行的方式，又该怎么说？ 接口的默认实现选择哪一种飞行方式都不行！
毁灭吧！！！！
这个时候，策略模式登场了
有一个设计原则： 封装变化原则
找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起
这样的概念很简单，几乎是每个设计模式背后的精神所在。所有的模式都提供了一套方法，让“系统中的某部分改变不会影响其他部分”。
好，该是把鸭子的行为从Duck类中取出的时候了!
我们知道Duck类内的fly()和quack()会随着鸭子的不同而改变。
为了要把这两个行为从Duck类中分开，我们将把它们从Duck类中取出来，建立一组新类来代表每个行为。
在“针对接口编程，而不是针对实现编程”的原则指导下（注意这里所说的接口指的是超类或实际的接口）,
我们定义两个接口: FlyBehavior，QuackBehavior，并且让所有的行为类都实现这两个接口中的其中之一
//飞行行为
interface FlyBehavior {
void fly();
}
//用翅膀飞
class FlyWithWings implements FlyBehavior {
@Override
public void fly() {
System.out.println("I'm flying!!");
}
}
//不会飞行
class FlyNoWay implements FlyBehavior {
@Override
public void fly() {
System.out.println("I can't fly");
}
}
//乘火箭飞行
class FlyRockedPowered implements FlyBehavior {
@Override
public void fly() {
System.out.println("I'm flying with a rocket!");
}
}
--------------------------------------------------------------------------------------
//叫的行为
interface QuackBehavior {
void quack();
}
//呱呱叫
class Quack implements QuackBehavior {
@Override
public void quack() {
System.out.println("Quack");
}
}
//没有声音的叫
class MuteQuack implements QuackBehavior {
@Override
public void quack() {
System.out.println("<< Silence >>");
}
}
//吱吱叫
class Squeak implements QuackBehavior {
@Override
public void quack() {
System.out.println("Squeak");
}
}
//鸭子的抽象类
abstract class Duck {
//组合
protected FlyBehavior flyBehavior;
protected QuackBehavior quackBehavior;
//执行 叫
public void performQuack() {
quackBehavior.quack();
}
//执行 飞
public void performFly() {
flyBehavior.fly();
}
//游泳
public void swim() {
System.out.println("All ducks float, even wooden duck!");
}
//形态
public abstract void display();
public void setFlyBehavior(FlyBehavior fb) {
this.flyBehavior = fb;
}
public void setQuackBehavior(QuackBehavior qb) {
this.quackBehavior = qb;
}
}
//野鸭子
class MallardDuck extends Duck {
public MallardDuck() {
quackBehavior = new Quack();
flyBehavior = new FlyWithWings();
}
@Override
public void display() {
System.out.println("I'm a real Mallard duck");
}
}
//模型鸭子
class ModelDuck extends Duck {
public ModelDuck() {
flyBehavior = new FlyNoWay(); // 一开始，鸭模型是不会飞的
quackBehavior = new Quack();
}
@Override
public void display() {
System.out.println("I'm a model duck");
}
}
// ==============================================================
public class StrategyApp {
public static void main(String[] args) {
Duck mallard = new MallardDuck();
mallard.performQuack();
mallard.performFly();
System.out.println("=====================");
Duck model = new ModelDuck();
model.performFly();
model.performQuack();
model.setFlyBehavior(new FlyRockedPowered());
model.performFly();
}
/**
* Quack
* I'm flying!!
* =====================
* I can't fly
* Quack
* I'm flying with a rocket!
*
* 进程已结束,退出代码0
*/
}
// ==============================================
//唐老鸭
class Tang extends Duck {
public Tang() {
flyBehavior = new FlyWithWings();
quackBehavior = new MuteQuack();
}
@Override
public void display() {
System.out.println("外观是唐老鸭");
}
}
2、策略模式基本介绍
策略模式（Strategy Pattern）中，定义算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户
3、策略模式UML 类图
风语者！平时喜欢研究各种技术，目前在从事后端开发工作，热爱生活、热爱工作。
站长推荐
- U8W/U8W-Mini使用与常见问题解决
U8W/U8W-Mini使用与常见问题解决 - stm32使用HAL库配置串口中断收发数据（保姆级教程）
stm32使用HAL库配置串口中断收发数据（保姆级教程） - SpringSecurity实现前后端分离认证授权
SpringSecurity实现前后端分离认证授权 - 【社区图书馆】伴我前行的一本书《The C Programming Language》
【社区图书馆】伴我前行的一本书《The C Programming Language》 - 分享几个国内免费的ChatGPT镜像网址(亲测有效)
分享几个国内免费的ChatGPT镜像网址(亲测有效)