设计模式--观察者模式

设计模式之观察者模式 本文先是介绍了观察者模式,给出定义、重要的角色、具体的代码实现。然后介绍了EventBus,从使用到刨析原理。最后我们又简单地对照了一下观察者模式和监听器模式。 阅读详情

简介

观察者模式(又被称为发布-订阅(Publish/Subscribe)模式,属于行为型模式的一种,它定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时,会通知所有的观察者对象,使他们能够自动更新自己。

观察者模式结构图如下:
在这里插入图片描述

角色

通过结构图可以发现观察者模式一共有四个角色:
(1)Subject:抽象主题,他把所有观察者对象保存在一个集合里,可以有任意数量的观察者,抽象主题提供一个接口,可以增加和删除观察者对象。
(2)ConcreteSubject:具体主题,该角色将有关状态存入具体观察者对象,在具体主题的内部状态发生改变时,给所有注册过的观察者发送通知。
(3)Observer:抽象观察者,是观察者者的抽象类,它定义了一个更新接口,使得在得到主题更改通知时更新自己。
(4)ConcrereObserver:具体观察者,实现抽象观察者定义的更新接口,以便在得到主题更改通知时更新自身的状态。

简单示例

1.创建Subject抽象主题角色。

public abstract class Subject {
    protected ArrayList observers=new ArrayList<>();
    //把观察者对象添加到观察者集合中
    public void attach(Observer observer) {
        observers.add(observer);
    }
    //把观察者对象剔除到观察者集合中
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    //声明抽象方法
    public abstract void notifyObserver();
}

2.创建ConcreteSubject具体主题角色。继承抽象类并实现通知观察者的方法。

public class ConcreteSubject extends Subject {
    @Override
    public void notifyObserver() {
        System.out.println("实现观察者的方法,准备发送消息给观察者....");
        for (Object o : observers){
            ((Observer)o).update();
        }
    }
}

3.创建Observer抽象观察者角色,定义一个更新的方法。

public interface Observer {
    public void update();
}

4.定义两个ConcrereObserver具体观察者角色,测试是否能够同时收到消息并更新状态。

public class ConcreteObserver implements Observer{
    private String observerName;
    public ConcreteObserver(String observerName) {
        this.observerName = observerName;
    }
    @Override
    public void update() {
        System.out.println(observerName + "收到更新消息,准备更新状态....");
    }
}

public class ConcreteObserverOther implements Observer {
    private String observerName;
    public ConcreteObserverOther(String observerName) {
        this.observerName = observerName;
    }
    @Override
    public void update() {
        System.out.println(observerName + "同样收到更新消息,准备更新状态....");
    }
}

5.Client(Main验证)

public class ObserverMain {
    public static void main(String[] args) {
        Subject subject = new ConcreteSubject();
        Observer observer1 = new ConcreteObserver("observer1");
        Observer observer2 = new ConcreteObserverOther("observer2");
        subject.attach(observer1);
        subject.attach(observer2);
        subject.notifyObserver();
    }
}

在这里插入图片描述

树莓派与ROS2 树莓派与ROS2(Robot Operating System 2)的结合使用为机器人开发、自动化控制以及物联网项目提供了强大的平台。 阅读详情

相关推荐

无刷电机FOC控制入门:磁场、洛伦兹力与坐标转换详解

本文深入解析无刷电机FOC(磁场定向控制)的核心原理,从电磁学基础的磁场与洛伦兹力出发,详细阐述了如何通过Clarke变换、Park变换等坐标转换技术,将三相交流解耦为直流量进行控制,最终利用SVPWM技术实现平滑、高效的电机驱动。文章旨在帮助开发者理解FOC的物理本质与数学框架,为机器人、无人机等高性能应用奠定基础。

weixin_29306011的博客 266

设计模式之观察者模式(ObserverPattern)

设计模式之观察者模式(ObserverPattern) 文章目录设计模式之观察者模式(ObserverPattern)一.观察者模式(ObserverPattern)二.编程实例1.进制转换器2.客人敲门案例 一.观察者模式(ObserverPattern) 在生活中会遇到很多使用观察者模式的案例,比如股票跌涨后,股民作为观察者会对股票进行交易;客人来敲门,门铃响了之后管家就会去开门等等。其中观...

Worthy_Wang的博客 622

Ubuntu离线情况下安装gcc编译器

Ubuntu离线情况下安装gcc编译器1.系统版本2.安装说明3.异常处理 1.系统版本 (1)Ubuntu系统版本:20.04.1LTS; (2)gcc编译器版本:gcc-9.3.0(下载链接为https://download.youkuaiyun.com/download/qq_18350351/13762214); 当前可找到的gcc最新版本为gcc-10,但是笔者在安装gcc-10版本时发现一些依赖项无法安装,因此选取了gcc-9版本。如果是在联网情况下安装,直接使用apt相关的安装指令即可。 2.安装说明 安

GreenHand的博客 3932

设计模式之观察者模式ObserverPattern(十一)

观察者模式 (Observer Pattern) 是一种行为型设计模式,又被称为发布-订阅 (Publish/Subscribe) 模式,它定义了对象之间的一种一对多的依赖关系,使得当一个对象的状态发生变化时,所有依赖于它的对象都会自动收到通知并更新。

徐泗空的博客 1047

LSTM模型股价波动率预测(含Python代码)

源代码文件可在gzh’finance褪黑素'回复【24012203】获取。

celiaweiwei的博客 3774

完整的申请邓白氏编码的流程(手把手教你申请邓白氏编码)

申请公司的苹果开发者账号和企业级的苹果开发者账号时,都会用到邓白氏编码,也就是我们申请苹果开发者账号时需要填写的D-U-N-S Number。     申请这个邓白氏编码是免费的,但是从像华夏邓白氏公司提交申请到可以申请苹果开发者账号来用这个9位的D-U-N-S Number,需要一段时间,我申请得到D-U-N-S Number,用了8个工作日(不算周末哦)

wxw2011014003的博客 9万+

设计模式之ObserverPattern观察者模式

现实世界中,许多对象并不是独立存在的,其中一个对象的行为发生改变可能会导致一个或者多个其他对象的行为也发生改变。例如,某种商品的物价上涨时会导致部分商家高兴,而消费者伤心;还有,当我们开车到交叉路口时,遇到红灯会停,遇到绿灯会行。 在软件世界也是这样,例如,Excel 中的数据与折线图、饼状图、柱状图之间的关系;MVC 模式中的模型与视图的关系。所有这些,如果用观察者模式来实现就非常方便。 观察者Observer模式的特点和定义: 观察者(Observer)模式的定义:指多个对象间存在一对多的依赖关系,当一

haoyuegongzi的博客 326

三. zemax光学设计流程+案例

文章目录zemax 基本操作:1. 建立光学基本模型2. 像质评价3. 优化(重点)4. 公差分析简单镜头设计 zemax 基本操作: 1. 建立光学基本模型 2. 像质评价 3. 优化(重点) 对系统设定的约束条件或目标值 统称为操作数。 操作数: 光学特性参数(焦距EFFL,近轴放大率PMAG,入瞳位置EMPP) 像差参数(球差SPHA,彗差COMA,像散ASTI) 边界条件(中心厚度值CTVA,边缘厚度值ETAV) 优化的主要步骤: 设置评价函数和优化操作数 一般小像差系统采用波像差 构建

Taiiiii的博客 8051

设计模式-观察者模式

观察者模式,是一种非常常见的设计模式,在很多系统中随处可见,尤其是涉及到数据状态发生变化需要通知的情况下。本文以AbstractCursor为例子,展开分析。观察者模式,Observer Pattern,是一个很实用的模式,本人曾经接触到的各种平台以及曾经参与项目中打印模板解释器中都用到了此模式。 1.意图定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知...

weixin_34268843的博客 285

科大讯飞(1): 环形6麦语音唤醒—驱动板上的接口

介绍环形麦阵列驱动板上的接口,及其疑问

bing_feilong的博客 1175

CKAD-CN考试之路----12

显然,对应的value都已经实现了加密.保存退出,等待pod重新创建。确认secret是否被加密。编辑secret文件。

Q先生 445

设计模式-观察者模式-Observer Pattern

观察者模式的优点包括实现了观察者和被观察者之间的解耦,增加了程序的可扩展性,并且可以动态地添加或移除观察者。:观察者模式能够将被观察者(Subject)和观察者(Observer)解耦,使得被观察者的改变不会直接影响到观察者,两者之间的依赖关系降低。:在需要实现通知和消息传递的系统中,观察者模式可以用来通知用户或系统组件关于状态变化的信息,如电子邮件客户端中的新邮件通知。:在观察者模式中,如果一个观察者在更新时发生错误,可能会影响到其他观察者的更新,这需要在设计时考虑错误处理机制。

wesigj的博客 1482

【用unity实现100个游戏之1】制作类元气骑士、挺进地牢——俯视角射击游戏多种射击效果(二)(附源码)

这篇文章我们将继续实现曲线射击与两种不需要实体子弹的射击方式 源码在文章末尾。

向宇的博客,专注php/web全栈 unity游戏开发,欢迎大家评论纠错 5059

【24种设计模式】观察者模式(Observer Pattern)

这种模式实现了一种一对多的对象依赖关系,当一个对象的状态改变时,所有依赖它的对象都会得到通知并自动更新。总结起来,观察者模式通过定义主题和观察者之间的接口,实现了一种松耦合的对象间通信方式。观察者模式中,通知观察者的算法骨架是固定的,但具体的通知操作可以由不同的观察者进行实现。在状态模式中,状态的改变会导致行为的改变,而在观察者模式中,状态的改变会导致通知给观察者。发布-订阅模式:发布-订阅模式是观察者模式的一种扩展,它将观察者分组,通过消息队列、事件总线等机制实现观察者与主题之间的松耦合通信。

Bankcary的博客 632

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

设计模式-观察者模式(Observer Pattern)

观察者模式 定义 观察者模式,又被称为发布-订阅(Publish/Subscribe)模式,它定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时,会通知所有的观察者对象。 类型 行为型。 角色 抽象主题(Subject)角色:也叫抽象目标类,它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法,以及通知所有观察者的抽象方法。 具体主题(Co...

kaven 1451

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

c++ 设计模式_设计模式行为型:观察者模式(ObserverPattern)

定义对象之间的一种一对多依赖关系,使得每一个对象发生状态的变化时,其相关依赖对象皆得到通知并被自动更新,又称为发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependence)模式。结构图角色与理解观察者模式共分为四种角色: Subject(目标类):被观察的对象,内部定义一个观察者集合,并...

weixin_39974223的博客 110

设计模式——行为型——观察者模式ObserverPattern

https://en.wikipedia.org/wiki/Observer_pattern

bbllbbcpt的专栏 304

设计模式教程:观察者模式(Observer Pattern)

定义对象之间的一对多依赖关系,当一个对象状态变化时,所有依赖于它的对象都会得到通知并自动更新。

遇见伯灵说的博客 1245

设计模式之观察者模式(Observer Pattern)

观察者模式定义 Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. 定义对象之间一种一对多的依赖关系,使得每当一个对象改变状态,则所有依赖于它的对象都会得到...

程铭程铭你快成名的博客 3589

Java 设计模式——观察者模式(Observer Pattern)

    前言 一、简介 二、实现步骤 (1)实现方式: (2)举例: (3)步骤简化版: 三、代码实现 四、总结 五、Demo地址 六、参考文档 七、内容推荐 前言 本来没想写前言的,感觉就是一堆废话。那就当废话浏览一下吧,只是提醒一下自己一些注意的东西。 在许多博客当中看到把观察者模式又称呼为发布-订阅模式。其实我感觉两者确实很相似,但还是有一丢丢的区别: 在...

斌林诚上的博客 726

23种设计模式——观察者模式(Observer Pattern)​详解

本文介绍了23种经典设计模式之——观察者模式(Observer Pattern)​的说明及使用。

Meteors.的博客 1224

设计模式之观察者模式(Observer Pattern),C++篇

观察者模式是一种行为设计模式,用于对象间一对多的依赖关系。当被观察对象状态改变时,会自动通知所有依赖的观察者。该模式包含四个核心角色:主题(Subject)、观察者(Observer)、具体主题(Concrete Subject)和具体观察者(Concrete Observer)。适用场景包括事件处理系统、消息传递等需要松耦合通知机制的场合。代码示例展示了C++实现,通过主题维护观察者列表,在状态变化时循环通知所有观察者进行更新。该模式有效降低了对象间的耦合度,适用于状态变化引发连锁反应的系统设计。

guoguojiang_的博客 1003

设计模式中的观察者模式(Observer Pattern)

在软件开发中,经常遇到对象之间存在依赖关系的情况,例如GUI 组件事件处理、消息订阅系统、股票价格更新、数据监听等。如果使用传统的方法(如轮询),不仅浪费资源,还可能导致数据不同步。观察者模式(Observer Pattern)提供了一种一对多的依赖关系,当被观察对象(Subject)状态发生变化时,会自动通知所有观察者(Observer),从而实现低耦合、自动更新的通知机制。本文将详细介绍观察者模式的概念、应用场景,并通过 Python 代码示例展示其实现。

1100

设计模式——观察者模式(Observer Pattern)+ Spring相关源码

当一个对象的状态发生改变时,其所有依赖者(观察者)都会收到通知并自动更新

码鹿的记录 1127

设计模式---观察者模式(DesignPattern_Observer)

摘录自:设计模式与游戏完美开发 十年磨一剑,作者将设计模式理论巧妙地融入到实践中,以一个游戏的完整实现呈现设计模式的应用及经验的传承 《轩辕剑》之父——蔡明宏、资深游戏制作人——李佳泽、Product Evangelist at Unity Technologies——Kelvin Lo、信仁软件设计创办人—— 赖信仁、资深3D游戏美术——刘明恺 联合推荐全书采用了整合...

su9257的博客 162
上一篇: 设计模式--迭代器模式
下一篇: 设计模式--中介者模式
CodersCoder
博客等级 码龄10年 90粉丝 258原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值