HeadFirst 设计模式（一）策略模式（Strategy Pattern）

最新推荐文章于 2022-01-19 22:16:11 发布
最新推荐文章于 2022-01-19 22:16:11 发布
阅读量400 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 策略模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qqfo24/article/details/105811368
版权

策略模式（Strategy Pattern）

定义了算法族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。

设计原则

  1. 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起
  2. 针对接口编程，而不是针对实现编程
  3. 多用组合，少用继承

模拟鸭子游戏

有一款模拟鸭子游戏，游戏中会出现各种鸭子，一边游泳，一边呱呱叫。根据面向对象技术，设计了一个鸭子的超类，让各种鸭子继承这个超类。

public abstract class Duck {
    public void quack() {
        System.out.println("呱呱叫");
    }

    public void swim() {
        System.out.println("游泳");
    }

    public abstract void display();
}

class MallardDuck extends Duck {
    @Override
    public void display(){
        //外观是绿头
        System.out.println("外观是绿头");
    }
}

public class RedheadDuck extends Duck {
    @Override
    public void display() {
        //外观是红头
        System.out.println("外观是红头");
    }
}

测试代码：

public class Main {
    public static void main(String[] args) {
        MallardDuck mallardDuck = new MallardDuck();
        mallardDuck.display();
        mallardDuck.quack();
        mallardDuck.swim();
        RedheadDuck redheadDuck = new RedheadDuck();
        redheadDuck.display();
        redheadDuck.quack();
        redheadDuck.swim();
    }
}

运行结果：

外观是绿头
呱呱叫
游泳
外观是红头
呱呱叫
游泳

让鸭子会飞

某一天，增加了一个需求，需要让鸭子会飞。于是在 Duck 类中增加了一个 fly() 方法。

可怕的问题来了，某天增加了一种橡皮鸭（不会飞、会吱吱叫）、一种诱饵鸭（不会飞、不会叫）。

由于继承的原因，橡皮鸭、诱饵鸭都变成了会飞、会呱呱叫。解决办法就是在橡皮鸭、诱饵鸭类中覆盖 fly() 和 quack() 方法。

public abstract class Duck {
    public void quack() {
        System.out.println("呱呱叫");
    }

    public void swim() {
        System.out.println("游泳");
    }

    public void fly() {
        System.out.println("飞");
    }

    public abstract void display();
}

public class RubberDuck extends Duck {
    @Override
    public void display() {
        System.out.println("外观是橡皮鸭");
    }

    @Override
    public void quack() {
        System.out.println("吱吱叫");
    }

    @Override
    public void fly() {
        System.out.println("不会飞");
    }
}

public class DecoyDuck extends Duck{
    @Override
    public void display() {
        System.out.println("外观是诱饵鸭");
    }

    @Override
    public void quack() {
        System.out.println("不会叫");
    }

    @Override
    public void fly() {
        System.out.println("不会飞");
    }
}

测试代码：

public class Main {
    public static void main(String[] args) {
        MallardDuck mallardDuck = new MallardDuck();
        mallardDuck.display();
        mallardDuck.quack();
        mallardDuck.swim();
        mallardDuck.fly();
        RedheadDuck redheadDuck = new RedheadDuck();
        redheadDuck.display();
        redheadDuck.quack();
        redheadDuck.swim();
        redheadDuck.fly();
        RubberDuck rubberDuck = new RubberDuck();
        rubberDuck.display();
        rubberDuck.quack();
        rubberDuck.swim();
        rubberDuck.fly();
        DecoyDuck decoyDuck = new DecoyDuck();
        decoyDuck.display();
        decoyDuck.quack();
        decoyDuck.swim();
        decoyDuck.fly();
    }
}

运行结果：

外观是绿头
呱呱叫
游泳
飞
外观是红头
呱呱叫
游泳
飞
外观是橡皮鸭
吱吱叫
游泳
不会飞
外观是诱饵鸭
不会叫
游泳
不会飞

利用继承来提供Duck的行为，会导致以下问题：

  1. 代码在多个子类中重复
  2. 运行时的行为不容易改变
  3. 很难知道所有鸭子的全部行为
  4. 改变会牵一发动全身，造成其他鸭子不想要的改变

利用接口实现

把 fly() 从超类中提取出来，放进一个 Flyable 接口，这么一来，只有会飞的鸭子才实现。同样也增加一个 Quackable 接口，因为有的鸭子不会叫。

public abstract class Duck {
    public void swim(){
        System.out.println("游泳");
    }

    public abstract void display();

}

public interface Flyable {
    public void fly();
}

public interface Quackable {
    public void quack();
}

public class MallardDuck extends Duck implements Flyable,Quackable {
    @Override
    public void display() {
        System.out.println("外观是绿头");
    }

    @Override
    public void fly() {
        System.out.println("飞");
    }

    @Override
    public void quack() {
        System.out.println("呱呱叫");
    }
}

public class RedheadDuck extends Duck implements Flyable,Quackable {
    @Override
    public void display() {
        System.out.println("外观是红头");
    }

    @Override
    public void fly() {
        System.out.println("飞");
    }

    @Override
    public void quack() {
        System.out.println("呱呱叫");
    }
}

public class RubberDuck extends Duck implements Quackable {
    @Override
    public void display() {
        System.out.println("外观是橡皮鸭");
    }

    @Override
    public void quack() {
        System.out.println("吱吱叫");
    }
}

public class DecoyDuck extends Duck {
    @Override
    public void display() {
        System.out.println("外观是诱饵鸭");
    }
}

测试代码：

/**
 * 利用接口来实现，重复代码变多
 */
public class Main {
    public static void main(String[] args) {
        MallardDuck mallardDuck = new MallardDuck();
        mallardDuck.display();
        mallardDuck.quack();
        mallardDuck.swim();
        mallardDuck.fly();
        RedheadDuck redheadDuck = new RedheadDuck();
        redheadDuck.display();
        redheadDuck.quack();
        redheadDuck.swim();
        redheadDuck.fly();
        RubberDuck rubberDuck = new RubberDuck();
        rubberDuck.display();
        rubberDuck.quack();
        rubberDuck.swim();
        // 不会飞
        // rubberDuck.fly();
        DecoyDuck decoyDuck = new DecoyDuck();
        decoyDuck.display();
        // 不会叫
        //decoyDuck.quack();
        decoyDuck.swim();
        // 不会飞
        //decoyDuck.fly();
    }
}

运行结果：

外观是绿头
呱呱叫
游泳
飞
外观是红头
呱呱叫
游泳
飞
外观是橡皮鸭
吱吱叫
游泳
外观是诱饵鸭
游泳

我们知道，并非所有的子类都具有飞行和呱呱叫的行为，所以继承并不是适当的解决方法。虽然利用 Flyable 和 Quackable 接口可以解决一部分问题，但是会造成代码无法复用，重复代码变多（假如有48种鸭子，每种鸭子都要去实现 fly() 和 quack() 方法）。

分开变化和不会变化的部分

将鸭子会变化的行为 fly 和 quack 放在分开的类中，此类专门提供某行为接口的实现。

这样的设计，飞行和呱呱叫的行为已经和鸭子无关，可以被其他对象复用。

整合鸭子的行为

在鸭子类中加入两个实例变量 flyBehavior 、quackBehavior，声明为接口类型。

每个鸭子都会动态地设置这两个变量以在运行时引用正确的行为类型（FlyWithWings 、Squeak 等）



定义行为：

public interface FlyBehavior {
    public void fly();
}

public class FlyWithWings implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("飞");
    }
}

public class FlyNoWay implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("不会飞");
    }
}

public interface QuackBehavior {
    public void quack();
}

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

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

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

鸭子类：

public abstract class Duck {
    
    FlyBehavior flyBehavior;
    QuackBehavior quackBehavior;

    public abstract void display();
    
    public void swim() {
        System.out.println("游泳");
    }

    public void performQuack() {
        quackBehavior.quack();
    }

    public void performFly() {
        flyBehavior.fly();
    }

    public void setFlyBehavior(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }

    public void setQuackBehavior(QuackBehavior quackBehavior) {
        this.quackBehavior = quackBehavior;
    }
}

绿头鸭实现类：

public class MallardDuck extends Duck {
    @Override
    public void display() {
        System.out.println("外观是绿头");
    }

    public MallardDuck(){
        quackBehavior = new Quack();
        flyBehavior = new FlyWithWings();
    }
}

测试代码：

public class TestMallardDuck {
    public static void main(String[] args) {
        Duck mallard = new MallardDuck();
        mallard.display();
        mallard.swim();
        mallard.performFly();
        mallard.performQuack();
    }
}

运行结果：

外观是绿头
游泳
飞
呱呱叫

动态设定行为

创建一个模型鸭，一开始是不会飞的，后面增加一个火箭飞行的行为，让模型鸭可以飞。

public class ModelDuck extends Duck {
    @Override
    public void display() {
        System.out.println("外观是模型鸭");
    }

    public ModelDuck(){
        flyBehavior = new FlyNoWay();
        quackBehavior = new Quack();
    }
}

public class FlyRocketPowered implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("火箭飞行");
    }
}

测试代码：

public class TestModelDuck {
    public static void main(String[] args) {
        Duck model = new ModelDuck();
        model.display();
        model.swim();
        model.performFly();
        model.performQuack();
        // 动态改变行为
        model.setFlyBehavior(new FlyRocketPowered());
        model.performFly();
    }
}

运行结果：

外观是模型鸭
游泳
不会飞
呱呱叫
火箭飞行

总结

多用组合，少用继承。

使用组合建立系统具有很大的弹性，不仅可将算法族封装成类，更可以在运行时动态改变行为。

yujunyi_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Head First设计模式(完整高清版).pdf
05-21
Head First设计模式(完整高清版).pdf，涵盖了各种宝贵的设计思想！
【HeadFirst】设计模式
最新发布
weixin_42310794的博客
05-20 3663
系列文章目录 `headfirst 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分
HeadFirst设计模式（模式总览速查）
冰码思维库
03-29 880
本文用于记录本人阅读完HeadFirst设计模式一书后对此书的总结，总结系个人理解并简化提炼，方便使用设计模式时速查，如有错漏，请积极指出，本人将虚心接受并及时改正。
Activity的四种启动模式
FlippedY的博客
09-25 722
Activity的四种启动模式 附加：返回栈是一组存放Activity集合的栈，用来管理Activity。当Activity位于栈顶时，Activity则会显示给用户（系统总是显示栈顶的Activity给用户），Activity可叠加，每次创建一个新的Activity，新的Activity则会入栈；若调用finish()方法或按下返回键（bankspace）,此时Activity会出栈（Activity会销毁）。 standard模式 默认情况下，Activity的启动方式为standard模式，在此模
HeadFirst设计模式(一)策略者模式
whyrookie的博客
08-10 359
最近在看HeadFirst设计模式一书，作为一个半路出家的程序员，感觉很多东西需要学习，学习的路程中有些东西学了当时觉得理解了，但日常工作中没有使用到渐渐的自己就忘记了。----------------------上面就是写者系列的博客的原因，主要是为了巩固知识，忘记在那个博主那边看过这么一句话，知识学了后总结了才变成自己的。 策略者模式----定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。 当然这只是理论的东西，说实话我现在都没理解这个理论是啥，下面我用..
C++实现HeadFirst策略模式设计模式
12-22
　Head First设计模式中介绍策略模式时以Duck类作为样例。当中用flyBehavior和quackBehavior两个接口引用变量代表鸭子飞行和鸭子叫这两种行为，通过改变flyBehavior和quackBehavior来满足不同的Duck子类的不同行为...
Head First 设计模式（中文版）
03-02
《Head First设计模式》(中文版)共有14章，每章都介绍了几个设计模式，完整地涵盖了四人组版本全部23个设计模式。前言先介绍这本书的用法；第1章到第11章陆续介绍的设计模式为Strategy、Observer、Decorator、...
HeadFirst设计模式源码（部分）
01-18
HeadFirst设计模式部分源码，按照《HeadFirst设计模式》的内容一步一步编写出的，可成功编译执行。
Head First 设计模式 源代码
04-23
Head First 设计模式中的源代码. 从官网下载, 可以方便学习.
HeadFirst设计模式之策略模式
qq_44936410的博客
01-19 521
设计模式的策略模式讲解。
headfirst设计模式
10-27
深入浅出设计模式。可以说是入门设计模式最好的一本书，感觉比国内的那一本好，介绍的很细致，当然这也是缺点之一，讲解细致必然篇幅很长，缺点二是只介绍了部分模式。总的来说入门还是挺好的。
HeadFirst设计模式高清非扫描中文版.zip.002
01-14
Head First设计模式高清非扫描中文版.zip.002。一共三个压缩包，都上传了
Head First Design Patterns（中文版）设计模式 java
04-18
Head First Design Patterns（中文版）设计模式 java。 Head First Design Patterns（中文版） 本资源转载自网络，如有侵权，请联系上传者或csdn删除 本资源转载自网络，如有侵权，请联系上传者或csdn删除 设计模式 java
Head First设计模式-中文版(高清PDF版)
12-18
强大的写作阵容。本书作者Eric Freeman；ElElisabeth Freeman是作家、讲师和技术顾问。Eric拥有耶鲁大学的计算机科学博士学位，E1isabath拥有耶鲁大学的计算机科学硕士学位。FHBert Bates是畅销的HeadFirst系列书籍的创立者，也是Sun公司Java开发员认证考试的开发者。本书的产品设计应用神经生物学、认知科学，以及学习理论，这使得这本书能够将这些知识
HeadFirst设计模式源码
05-02
书籍<HeadFirst设计模式>随书源码，可直接运行，条理清晰
Head First 设计模式各模式思想及总结
锄禾日当午，啥都不靠谱；闲来没事做，不如写博客。
10-03 1365
虽然接触设计模式很久了，但是以前没有做笔记，也没留下什么代码，只怪当初太年轻呀~现在要重新回顾了。记住，设计模式注重的是思想，并不是具体实现，不要被设计模式限制了自己，也并不是我们写代码一定要想着怎么用设计模式来实现出来，按照设计模式的规范设计出来，一般情况下，把代码封装好，把变化的东西封装好，对外暴露不变的方法或接口，代码按照功能模块拆分成类和方法，做到这些已经可以让后来看自己代码的人不骂自己了...
head first 23个设计模式总结
痴人说梦c的博客
02-24 974
文章目录<Head First设计模式>总结 根据GOF四人组对设计模式的总结划分，设计模式分为三大类： 创建型： 涉及到对象实例化，这类模式都提供一个方法，将客户从所需要实例化的对象中解耦 结构型 可以让你把类或者对象组合到更大的结构中 行为型 涉及到类和对象如何交互及分配职责 创建型 工厂方法 描述： 定义了一个创建对象接口，由子类决定实例化类是哪一个。工厂方法将类的实例化推迟到了子类。 结构： 抽象工厂方法 描述： 用于提供一个创建一系列或相关依赖对象的接口，而无需指定他
Head First设计模式（中文版）PDF
@you的博客
09-05 1万+
https://pan.baidu.com/s/1YGPvwmd-nyBpG5qD2NJlOQ
【书】Head First设计模式(中文版)
热门推荐
GreAmbWang的博客
12-15 3万+
介绍了23种设计模式 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值