设计模式——个人学习之观察者模式

最新推荐文章于 2024-08-28 08:00:00 发布
最新推荐文章于 2024-08-28 08:00:00 发布
阅读量122 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34754162/article/details/107946951
版权

观察者模式

简介

如果有这样一个场景，比如：我们在游戏的时候，当我们完成一个主线任务的时候，可以能会同时开启多个支线任务，因此我们的支线任务一定是要等主角完成主线任务后，根据主角完成的质量或者说结果来开启对应的支线任务，因此支线任务就像一个观察者，一直盯着主角主线任务完成到哪里了，什么时候它才能公布出来，这就是观察者模式的实际场景应用。

观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。它是对象行为型模式。

这是观察者模式的UML图：

img

从图中我们可以罗列出它的结构：

  1. 抽象主题（Subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
  2. 具体主题（Concrete Subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
  3. 抽象观察者（Observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
  4. 具体观察者（Concrete Observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。

优缺点

观察者模式是一种对象行为型模式，其主要优点如下：

  1. 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。
  2. 目标与观察者之间建立了一套触发机制。

它的主要缺点如下：

  1. 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
  2. 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

代码实现

抽象主题角色：

package com.example.demo.basis.design.observer;

import java.util.ArrayList;

/**
 * @author: sunzhinan
 * @create: 2020-08-11 22:29
 * @description: 抽象角色类
 */
public abstract class Role {
    //定义一个集合，里面是存放这个角色有关的支线任务
    public ArrayList<SubTask> subTasksList = new ArrayList<>();

    //添加支线任务的方法
    public void putTask(SubTask subTask){
        subTasksList.add(subTask);
    }

    //子类实现的方法
    public abstract void notifyTask();

}

具体主题角色：

package com.example.demo.basis.design.observer;

/**
 * @author: sunzhinan
 * @create: 2020-08-11 22:39
 * @description: 主角1
 */
public class ProtagonistOne extends Role{
    @Override
    public void notifyTask() {
        System.out.println("-----开启支线任务-----");
        for ( SubTask subTask : subTasksList) {
            subTask.callMe();
        }
    }
}

抽象观察者角色：

package com.example.demo.basis.design.observer;

/**
 * 支线任务接口
 */
public interface SubTask {
    public void callMe();
}

具体观察者角色：

package com.example.demo.basis.design.observer;

/**
 * @author: sunzhinan
 * @create: 2020-08-11 22:31
 * @description: 支线任务1
 */
public class SubTaskOne implements SubTask{
    @Override
    public void callMe() {
        System.out.println("支线任务1已开启");
    }
}

package com.example.demo.basis.design.observer;

/**
 * @author: sunzhinan
 * @create: 2020-08-11 22:33
 * @description: 支线任务2
 */
public class SubTaskTwo implements SubTask{
    @Override
    public void callMe() {
        System.out.println("支线任务2已开启");
    }
}

测试类：

package com.example.demo.basis.design.observer;

/**
 * @author: sunzhinan
 * @create: 2020-08-11 22:43
 * @description: 测试类
 */
public class Test {
    public static void main(String[] args) {
        Role role = new ProtagonistOne();
        role.putTask(new SubTaskOne());
        role.putTask(new SubTaskTwo());

        role.notifyTask();
    }
}

结果：
    -----开启支线任务-----
	支线任务1已开启
	支线任务2已开启

上面的示例就一个简单的观察者模式基本框架，在这里我们可以丰富一下它，比如我们可以新加一个事件，当出现某个事件的时候，我们开启对应的支线任务。

事件：

package com.example.demo.basis.design.observer;

/**
 * @author: sunzhinan
 * @create: 2020-08-11 22:50
 * @description: 事件——通过泛型可以衍生出不同的角色事件类型
 */
public abstract class TaskEvent<T> {

    String taskName;

    String taskType;

    abstract T getSource();
}

package com.example.demo.basis.design.observer;

/**
 * @author: sunzhinan
 * @create: 2020-08-11 22:51
 * @description: Role角色事件类型
 */
public class OneTaskEvent extends TaskEvent<Role>{


    Role role;

    public OneTaskEvent(String taskName, String taskType, Role role) {
        this.taskName = taskName;
        this.taskType = taskType;
        this.role = role;
    }

    @Override
    Role getSource() {
        return this.role;
    }
}

其他类也需要做相应的变化

抽象主题角色：

package com.example.demo.basis.design.observer;

import java.util.ArrayList;

/**
 * @author: sunzhinan
 * @create: 2020-08-11 22:29
 * @description: 抽象角色类
 */
public abstract class Role {
    String roleType;

    public Role(String roleType) {
        this.roleType = roleType;
    }

    //定义一个集合，里面是存放这个角色有关的支线任务
    public ArrayList<SubTask> subTasksList = new ArrayList<>();

    //添加支线任务的方法
    public void putTask(SubTask subTask){
        subTasksList.add(subTask);
    }

    //子类实现的方法
    public abstract void notifyTask();

    public String getRoleType() {
        return roleType;
    }

    public void setRoleType(String roleType) {
        this.roleType = roleType;
    }

}

具体主题角色：

package com.example.demo.basis.design.observer;

/**
 * @author: sunzhinan
 * @create: 2020-08-11 22:39
 * @description: 主角1
 */
public class ProtagonistOne extends Role{
    public ProtagonistOne(String roleType) {
        super(roleType);
    }

    @Override
    public void notifyTask() {
        System.out.println("-----开启支线任务-----");
        OneTaskEvent oneTaskEvent = new OneTaskEvent("主线任务1", "kill boss", this);
        for ( SubTask subTask : subTasksList) {
            subTask.callMe(oneTaskEvent);
        }
    }
}

抽象观察者角色：

package com.example.demo.basis.design.observer;

/**
 * 支线任务接口
 */
public interface SubTask {
    public void callMe(TaskEvent taskEvent);
}

具体观察者角色：

package com.example.demo.basis.design.observer;

/**
 * @author: sunzhinan
 * @create: 2020-08-11 22:31
 * @description: 支线任务1
 */
public class SubTaskOne implements SubTask{
    @Override
    public void callMe(TaskEvent taskEvent) {
        System.out.println("支线任务1已开启");

        System.out.println("主线任务类型是 : " + taskEvent.taskType + " 已完成");
    }
}

package com.example.demo.basis.design.observer;

/**
 * @author: sunzhinan
 * @create: 2020-08-11 22:33
 * @description: 支线任务2
 */
public class SubTaskTwo implements SubTask{
    @Override
    public void callMe(TaskEvent taskEvent) {
        System.out.println("支线任务2已开启");
        Role source = (Role) taskEvent.getSource();
        System.out.println("主角角色是 : " + source.getRoleType());
        System.out.println("主线任务是 : " + taskEvent.taskName + " 已完成");

    }
}

测试类：

package com.example.demo.basis.design.observer;

/**
 * @author: sunzhinan
 * @create: 2020-08-11 22:43
 * @description: 测试类
 */
public class Test {
    public static void main(String[] args) {
        Role role = new ProtagonistOne("法师");
        role.putTask(new SubTaskOne());
        role.putTask(new SubTaskTwo());

        role.notifyTask();
    }
}

结果：
    -----开启支线任务-----
    支线任务1已开启
    主线任务类型是 : kill boss 已完成
    支线任务2已开启
    主角角色是 : 法师
    主线任务是 : 主线任务1 已完成

所以可以看出，这样的观察者模式内容更加丰富，同时也能感觉代码的可维护性增强了。
其实观察者模式在实际的运用中有很多，我们常说的事件，比如js中的事件，spring中的事件等等都是使用的这个设计模式。

参考文档：《GoF设计模式》

勿白头空悲切
关注
专栏目录
设计模式实现——观察者模式
09-04
在《设计模式实现——观察者模式》这篇博客中，作者可能详细解释了观察者模式的概念、结构以及其在实际编程中的应用。以下是对观察者模式的详细阐述： 1. **模式定义**：观察者模式是一种对象行为型模式，它允许...
Android 设计模式学习之观察者模式应用实例
05-25
本文将深入探讨一种常用的设计模式——观察者模式（Observer Pattern），并结合Android实际应用给出实例解析。 观察者模式是一种行为设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，...
python面试题——设计模式之观察者模式
python全栈
08-21 1546
观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。观察者模式又称："发布-订阅"模式。比如，微信公众号，就是一种观察者模式的应用：一个公众号对应了多个（N）个 订阅者，公众号发布了新的文章，所有的订阅者都会被通知并更新。也就相当于，我们所有的订阅者就是观察者，我们观察这个公众号（发布者），他一更新，我们就能知道.
Java 设计模式——观察者模式
代码星辰的博客
07-16 4279
本文介绍了观察者模式的相关知识。
设计模式 —— 观察者模式
qq_67693066的博客
06-10 1448
设计模式 —— 观察者模式
C++设计模式——观察者模式
zhangchuan7758的博客
12-09 3100
观察者模式：当一个对象状态更新时，会自动通知依赖它的对象。
设计模式——Observer(观察者)模式
qq_36566262的博客
04-21 2298
目录前言1 定义2 适用性3 结构3.1 结构图3.2 参与者4 应用举例4.1 Subject——Observable4.2 ConcreteSubject——ClockSubject4.3 Observer——Observer4.4 ConcreteObserver——ObserverOne、ObserverTwo4.5 测试程序——Client5 总结参考文献 前言 当一个对象与其它对象紧密关联，如果直接引用的话可能导致紧密耦合，如何描述这种一对多的关联关系？本文的观察者模式是一种思路。 1 定义 O
设计模式第5讲——观察者模式（Observer）
热门推荐
让~学习~成为一种习惯（橡 皮 人の技术博客）
06-02 1万+
观察者模式属于行为型模式。一、什么是观察者模式 二、特点 三、组成 四、应用场景4.1 生活场景4.2 程序场景 五、观察者模式实现5.0 UML类图5.1 Newspaper5.2 NewspaperImpl5.3 Subscriber5.4 SubscriberImpl5.5 测试
18行为型设计模式——观察者模式
qq_55610255的博客
08-28 1795
被观察者（Subject）：这是状态发生变化的对象，它维护一个观察者列表并提供方法来附加、移除和通知观察者。观察者（Observer）：这是对状态变化做出反应的对象，它通常有一个更新接口，允许被观察者调用这个接口来通知状态变化。Subject和Observer都是面向接口编程，因此具有自己的具体实现类。观察者模式的核心优势在于它能够减少对象之间的耦合性，使得系统更具扩展性和灵活性。其主要用于处理对象之间的依赖关系，使得当一个对象的状态发生变化时，所有依赖于它的对象都会自动得到通知并更新。
设计模式——观察者模式
秋雨绵绵
12-28 4329
本文简单介绍了关于设计模式的一种，观察者模式
设计模式（二）————观察者模式
YXXXYX的博客
11-06 3941
引言 观察者模式可以说是JDK中使用最多的模式之一，这个模式可以让你的对象随时随地的了解想要知道的情况，你还可以让某个对象在运行时决定是否要继续通知；观察者模式的定义为： 定义对象间一种一对多的依赖关系，使得当每一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新 从定义就可以看出，观察者模式主要就是两部分：主题（Subject）和观察者（Observer） 为了更清楚的了解观察者模式，下面将会用案例说明观察者模式； 天气预报项目 今天一个新的项目交到了你的手上，这个项目是一个天气预报公司的，他们想
设计模式——观察者模式（附代码示例）
枫陵的博客
05-26 2363
一. 传统方式 以天气预报以公告形式发送给第三方为例 1. 代码示例 CurrentConditions类，显示当前天气情况 public class CurrentConditions { private float temperature; private float pressure; private float humidity; //更新，第三方调用，推送 public void update(float temperature,...
Java设计模式——观察者模式
05-04
首先，我们来看"Java设计模式——观察者模式的两种情况"： 1. **主动通知**: 在这种情况下，被观察者对象在自身状态发生变化时，会主动调用`Observable`接口提供的`notifyObservers()`方法，将变化通知给所有注册的...
Android设计模式——观察者模式
09-27
简单易懂的观察者模式
report ETL .ffff
09-17
report ETL .ffff
基于ssm的共享充电宝管理系统设计与实现.docx
09-17
基于ssm的共享充电宝管理系统设计与实现.docx
操作系统大作业_Linux_命令行_OSWork.zip
最新发布
09-17
操作系统大作业_Linux_命令行_OSWork
Java项目-基于SSM+Jsp的社区管理与服务系统的设计与实现（源码+数据库脚本+部署视频+代码讲解视频+全套软件）
09-17
【基于SSM+Jsp的社区管理与服务系统的设计与实现】高分通过项目，已获导师指导。 本项目是一套基于SSM+Jsp的社区管理与服务系统，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的Java学习者。也可作为课程设计、期末大作业 包含：项目源码、数据库脚本、开发说明文档、部署视频、代码讲解视频、全套软件等，该项目可以直接作为毕设使用。 项目都经过严格调试，确保可以运行！
理解设计模式：状态模式与观察者模式解析
本文将聚焦于两种常用的设计模式——状态模式（State Pattern）和观察者模式（Observer Pattern）。状态模式允许一个对象根据其内部状态改变行为，而观察者模式则提供了一种对象间的一对多依赖关系，当一个对象的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值