如何将变量参数传递给观察者？
在软件开发中，观察者模式是一种常用的设计模式，用于实现对象之间的一对多依赖关系。当一个对象的状态发生变化时，它会自动通知所有依赖于它的观察者对象，使它们能够及时更新自己的状态。
要将变量参数传递给观察者，可以按照以下步骤进行操作：
- 定义观察者接口：创建一个观察者接口，其中包含一个方法用于接收变量参数。
public interface Observer {
void update(Object parameter);
}- 实现观察者类：创建一个或多个实现观察者接口的类，实现其update方法来处理接收到的变量参数。
public class ConcreteObserver implements Observer {
@Override
public void update(Object parameter) {
// 处理接收到的变量参数
}
}- 定义被观察者接口：创建一个被观察者接口，其中包含用于添加、删除和通知观察者的方法。
public interface Observable {
void addObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers(Object parameter);
}- 实现被观察者类：创建一个实现被观察者接口的类，实现其添加、删除和通知观察者的方法。
public class ConcreteObservable implements Observable {
private List<Observer> observers = new ArrayList<>();
@Override
public void addObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers(Object parameter) {
for (Observer observer : observers) {
observer.update(parameter);
}
}
}- 使用观察者模式：在需要传递变量参数的地方，创建一个被观察者对象，并添加相应的观察者对象。当变量参数发生变化时，调用被观察者对象的notifyObservers方法通知所有观察者。
public class Main {
public static void main(String[] args) {
ConcreteObservable observable = new ConcreteObservable();
Observer observer1 = new ConcreteObserver();
Observer observer2 = new ConcreteObserver();
observable.addObserver(observer1);
observable.addObserver(observer2);
// 变量参数发生变化
Object parameter = new Object();
observable.notifyObservers(parameter);
}
}观察者模式的优势在于解耦了观察者和被观察者之间的关系，使得它们可以独立地进行扩展和修改。它常被应用于事件驱动的系统、用户界面组件、消息通知等场景。
腾讯云提供了一系列云计算相关产品，如云服务器、云数据库、云存储等，可以根据具体需求选择适合的产品。具体产品介绍和相关链接地址可以参考腾讯云官方网站：https://cloud.tencent.com/
相关·内容
3回答
下面的Java示例试图在Swift 5中编写代码。
一般来说，我希望有一个Observable协议，它将被多个其他协议所采用。我需要这些协议是函数参数中的类型，这样这些函数就可以添加额外的观察者。
在Java中，这很容易做到。代码打印出来：
Observer 1 changed to 10
Observer 2 changed to 10
，
interface Observable<O> {
void addObserver(O observer);
}
interface Settings extends Observable<SettingsObserver&
浏览 0提问于2019-07-13得票数 1
回答已采纳
3回答
我正在尝试理解观察者模式，这是我在网上选择的一个简单代码：
import java.util.ArrayList;
import java.util.List;
/**
* The observer pattern is a software design pattern in which an object,
* called the subject, maintains a list of its dependents, called observers, and
* notifies them automatically of any state changes, usua
浏览 1提问于2015-10-05得票数 0
我知道模式观察者的用法，但就目前而言，我发现在观察者对象上进行操作是无用的，而您可以在不需要使用此设计模式的情况下执行相同的操作！
如果我错了，有没有人可以纠正我，并用一个具体的例子来解释这个设计模式的效用和重要性？
我可以看到它提供了更多的代码组织，但是我应该在什么时候使用它？
例如，下面是一个用PHP实现的观察者模式：
下面是被观察类或主题类
// Dès que cet attribut changera on notifiera les classes observatrices.
protected $name;
public function attach(SplObserv
浏览 0提问于2018-02-20得票数 1
我对我执行观察员模式有疑问，但完全分开关注。
下面的例子不是一个真实的生活代码，而是我想要做的一个例子。
在我的解决方案中，有两个项目层：
桌面层(视图、视图模型、模型)
服务库层(带观察者)
我的观点模型是一个订阅观察者的主题。
VM中的代码：
interface ISubject
{
void Subscribe(IObserverService observer);
void Unsubscribe(IObserverService observer);
void Notify();
}
public class MainWindowViewMod
浏览 2提问于2019-08-29得票数 0
回答已采纳
1回答
问题
我很难从“可重用的面向对象软件的元素”中理解观察者模式的以下UML图。有人能解释我为什么我的Java实现是错误的，以及我需要修改什么才能正确地实现它吗？
UML-图
尝试(但错)实现
public interface Subject {
public static final List<Observer> observers = new ArrayList<Observer>();
public void attach(Observer o);
public void detach(Observer o);
浏览 1提问于2021-03-16得票数 0
3回答
C#主题观察者体系结构问题
、、、、
我正在以稍微不同的方式使用Subject观察者设计模式来制作一个C#应用程序。
我将提供程序类传递给观察者类构造器，实现IObservable (这个方法有通知订阅它的所有类的OnNext()方法)，实现IObserver (它作用于提供者类发布的OnNext()方法)。
这样，每个观察者类都具有执行OnNext()方法通知其他类更改的能力。
因此，我的示例项目的一个非常简单的外观如下：
ProviderClass provider;
ObserverClass observer1;
ObserverClass observer2;
.......... observer3;
........
浏览 0提问于2015-03-27得票数 1
1回答
如何使观察者成为观察者模式中的默认观察者。例如，在本例中，来自
import scala.collection.mutable.ArrayBuffer
// Abstract implementation
trait Observable {
val observers = ArrayBuffer[Observer]()
def notifyObservers() {
for(observer <- observers)
observer.notification()
}
def addObserver(observer:Observer) {
浏览 1提问于2015-11-18得票数 1
回答已采纳
1回答
我想使用没有Spring事件的Spring来实现GoF观察者设计模式。
代码示例：
@Component
public class MyObservable extends java.util.Observable {
void myObservableMethod(Object obj){
notifyObservers(obj);
}
}
@Component
public class MyObserver implements java.util.Observer{
@Override
浏览 2提问于2017-06-22得票数 3
回答已采纳
3回答
我刚刚开始理解观察者模式是如何工作的。但现在我想用它。我看到了许多关于观察者模式的例子，但大多数例子只是简单地演示了该模式，并且没有显示它是为完成任务而实现的。
据我所知，观察者会收到被调查对象的通知。但是，我怎样才能让观察者做一些事情呢？
下面的代码是一个常见的观察者模式程序。我看到它在通知观察者时执行console.log (console.log("Observer " + number + " is notified!");)。这是我可以返回其他东西的地方吗:值、函数调用等等？
我看过简单数学的可视化示例，在通知观察者时更新计算(即成本+税收=总计)。但
浏览 1提问于2019-04-26得票数 4
回答已采纳
我有一个可观察的，通知它所有的注册观察员。
public void notifyObservers(T message) {
notifying = true;
for (Observer<T> observer : observers)
observer.notify(message);
notifying= false;
}
我在我的课堂上也有这样的方法：
public void removeObserver(final Observer<T> observer){
if (!this.observer
浏览 5提问于2015-09-11得票数 1
回答已采纳
4回答
需求
我正在尝试编写一个Observer / Observable对类。我想要参数化的Observer，以便类型安全的更新调用是可能的。想象一下这个版本：
class View implements Observer<Model> {
@Override
public void update(Model model) { render(model); } // no casting:)
}
而不是需要强制转换的这个版本：
class View implements Observer {
@Override
public void update(Ob
浏览 1提问于2015-02-22得票数 6
回答已采纳
1回答
主要目标是更新片段信息，主要来自它自己的类。
主要活动：
public class MainActivity extends AppCompatActivity {
final Handler GUIHandler = new Handler();
final Runnable r = new Runnable()
{
public void run()
{
updateFragments();
GUIHandler.postDelayed(this, 1000);
}
浏览 3提问于2015-11-11得票数 0
回答已采纳
因此，我正在学习设计模式，我目前正在研究观察者模式。
为了在原始的基础上实现它，我做了如下事情：
<?php
class Subject
{
private $foo;
private $bar;
private $observers = [];
public function addObserver(Observer $o)
{
$this->observers[] = $o;
}
public function removeObserver(Observer $o)
{
if
浏览 3提问于2016-09-01得票数 0
2回答
有没有一种RxJava连接观察者的方式？
我的意思是，不是：
Observer<Object> observer1 = new Observer<Object>() { // ... }
Observer<Object> observer2 = new Observer<Object>() {
@Override
public void onNext(Object event) {
observer1.onNext(event);
}
// ...
};
以便观察者链接在一起(当原始onNe
浏览 0提问于2016-10-15得票数 1
1回答
我想知道使用模板观察者配置的观察者模式是否比一般的观察者模式更方便。模板观察者的概念是一个可观察的类，它的一个特定的观察者类型被配置为一个模板。作为一个例子，我将展示一个普通观察者，并将其与模板观察者进行比较。
法线观测器模式
正常观察者界面：
public interface NormalObserver {
//Update method
void update(final String updateIn);
}
对于实现NormalObserver接口的每个类，update函数都是相同的。当您想要实现特定的观察者(例如具有不同更新参数的观察者)时，这会导致问题。
浏览 3提问于2017-08-03得票数 0
我正在从学习设计模式，为了获得自信，我计划在学习了相应的章节之后，在C++中实现每个模式。
关于观察者的模式，我真的在努力超越语言缩进的主要思想。
我一直在浏览以下内容：
实际上还有其他几个。
但是，当我开始用C++编写代码时，一些特定于语言的困难暴露了我对整个主题的一些误解，我无法用上面的liks来解决这个问题。然而，我在这里张贴，因为我有一个(表面上)工作代码。
示例代码如下所示，之后我列出了我对这个模式的理解和使用的一些关注。
#include <algorithm>
#include <iostream>
#include &
浏览 2提问于2020-03-22得票数 5
2回答
我正在尝试开发一个应用程序，如果PartNumber中有任何更改，人们就会得到通知。它是一个基于Spring的应用程序。下面是代码片段。
我在SaveSubscriptionIF中抽象了存储机制。存储和检索的实际细节在此接口的实现类中。实现类将在Spring之前注入。
外部应用程序调用我的setState()方法-传递新信息。
store.getObservers()方法返回Map，它具有要更新的观察者和相应的信息。
到目前一切尚好。store.getObservers()的实现部分受到了影响。该方法实现需要state数据，即从外部应用程序传递的新信息。
如何将“状态”数据传递给“SaveSu
浏览 3提问于2010-07-09得票数 1
回答已采纳
如何像Java一样用Python编写具有观察者/可观察性工具的程序？我会用Java写一些像下面这样的东西。
import java.util.Observable;
import java.util.Observer;
public class ObservDemo extends Object {
MyView view;
MyModel model;
public ObservDemo() {
view = new MyView();
model = new MyModel();
model.addObserver(view);
}
浏览 3提问于2012-11-23得票数 7
这个问题与我在中遇到的一个问题有关。因此，我想知道是否有一种完全不同的方法来实现它。
我有一个java.util.concurrent list，它由多个线程更新。 list 本身实现了Observable，然后我有另外两个Observers，它们在更改列表时会得到通知。
现在，Observers将只加载最新值(它们还没有)，而不是列表中可能包含的数千个值。
目前的概述如下：
public class Observer1 implements Observable {
}
public class Observer2 implements Observable {
}
public cla
浏览 0提问于2012-07-14得票数 1
错误是Cannot convert value of type '(O?, ObservedType) -> Void' to expected argument type '(AnyObject?, ObservedType) -> Void，但我觉得这很奇怪，因为O被约束为AnyObject。
对于上下文，我正在创建我自己的Observable类，但这个问题实际上是关于上面的特定错误消息，而不是我如何使用任何其他第三方框架来使用Observable。也就是说，在这种情况下，我如何正确地转换我的完成处理程序。
public class Observable
浏览 18提问于2021-02-18得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
即时通信 IM
对象存储活动推荐
腾讯云开发者
