观察者模式

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

基本定义：观察者模式是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实作事件处理系统。 

 实例：公司前台，观察老板动向

源代码：

package observer;

import java.util.ArrayList;

public class observer {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Secretary dabao =new Secretary();//前台秘书大宝
		//看股票同事
		StockObserver per1 =new StockObserver("小明",dabao);
		StockObserver per2 =new StockObserver("小红",dabao);
		//前胎记下两位同事
		dabao.Attach(per1);
		dabao.Attach(per2);
		//发现老板回来
		dabao.setAction("老板回来了");
		//通知两个同事
	    dabao.Notify();	
	}

}
class Secretary//前台秘书类——Sercretary依赖StockObserver
{//同时列表组合，用来添加请求帮忙的同事
	private ArrayList<StockObserver> observers = new ArrayList<StockObserver>();
	private String action;
	public void Attach(StockObserver observer ) {
		observers.add(observer);
	}
	public void Notify()//通过
	{
		for(int i=0;i<observers.size();i++)
		{
			observers.get(i).Update();
		}
	}
	public String getAction() {
		return action;
	}
	public void setAction(String action) {
		this.action=action;
	}
}
class StockObserver{//看股票同事类
	private String name;
	private Secretary sub;
	public StockObserver(String name,Secretary sub) {
		 this.name=name;
		 this.sub=sub;
	}
	public void Update()//得到前台的通知，赶快采取行动
	{//观察者类需要前台的状态
		System.out.println(sub.getAction()+name+"关闭股票性情，继续工作！");
	}
	
}

å¨è¿éæå¥å¾çæè¿°

 改进：耦合度太高，抽象类实现解耦合

package observer;

import java.util.ArrayList;
import java.util.Observable;

public class observer2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Subject dabao =new Boss();
		//看股票同事
		StockObserver per1 =new StockObserver("小明",dabao);
		NBAObserver per2 =new NBAObserver("小红",dabao);
		//前胎记下两位同事
		dabao.Attach(per1);
		dabao.Attach(per2);
		//发现老板回来
		dabao.setAction("老板回来了");
		//通知两个同事
	    dabao.Notify();	
	}

}
 abstract class Subject//抽象通知者
{//同时列表组合，用来添加请求帮忙的同事
	abstract void Attach(Observer observer);//添加观察者
	abstract void Detach(Observer observer);//删除观察者
	abstract void Notify();//通知观察者
	private String action;

	
	public String getAction() {//老板状态
		return action;
	}
	public void setAction(String action) {
		this.action=action;
	}
}
class Boss extends Subject{

	private ArrayList<Observer> observers = new ArrayList<Observer>();
	@Override
	void Attach(Observer observer) {
		// TODO Auto-generated method stub
		observers.add(observer);
	}

	@Override
	void Detach(Observer observer) {
		// TODO Auto-generated method stub
		observers.remove(observer);
	}

	@Override
	void Notify() {
		// TODO Auto-generated method stub
		for(int i=0;i<observers.size();i++) {
			observers.get(i).Update();
		}
	}
	
}
abstract class Observer{//看股票同事类
	protected String name;
	protected Subject sub;
	public Observer(String name,Subject sub) {
		 this.name=name;
		 this.sub=sub;
	}
	public abstract void Update();
	
}
class StockObserver extends Observer{

	public StockObserver(String name, Subject sub) {
		super(name, sub);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void Update() {
		// TODO Auto-generated method stub
	     //观察者类需要前台的状态
			System.out.println(sub.getAction()+name+"关闭股票性情，继续工作！");
		
	}


	
}
class NBAObserver extends Observer{

	public NBAObserver(String name, Subject sub) {
		super(name, sub);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void Update() {
		// TODO Auto-generated method stub
		System.out.println(sub.getAction()+name+"关闭NBA，继续工作！");
	}
	
}

观察者模式模板：

å¨è¿éæå¥å¾çæè¿°

package observer;

import java.util.ArrayList;

public class observer3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ConcreteSubject dabao =new ConcreteSubject();
		dabao.Attach(new ConcreObserver("X",dabao));
		dabao.Attach(new ConcreObserver("Y",dabao));
		dabao.Attach(new ConcreObserver("Z",dabao));
	    dabao.setAction("ABC");
	    dabao.Notify();
	}

}
 abstract class Subject//抽象通知者
{//同时列表组合，用来添加请求帮忙的同事
	private ArrayList<Observer> observers = new ArrayList<Observer>();
	public void Attach(Observer observer)//添加观察者
	{
		observers.add(observer);
	}
	
	public void Detach(Observer observer){
		observers.remove(observer);
	}//删除观察者

	public void Notify()//通知观察者
	{
		for(int i=0;i<observers.size();i++) {
			observers.get(i).Update();
		}
	}
	
}
class ConcreteSubject extends Subject{
	private String action;

	public String getAction() {
		return action;
	}

	public void setAction(String action) {
		this.action = action;
	}
	
}
abstract class Observer{//看股票同事类
 abstract void Update();
	
}
class ConcreObserver extends Observer{

	private String name;
	private String action;
	private ConcreteSubject sub;
	
	public ConcreObserver(String name, ConcreteSubject sub) {
		super();
		this.name = name;
		this.sub = sub;
	}

	@Override
	void Update() {
		// TODO Auto-generated method stub
		this.action=sub.getAction();
		System.out.println("观察者"+name+"的新的状态是"+action);
	}

	
}

JAVA中的观察者案例
狼来了——源代码：

package observer;

import java.util.Observer;
import java.util.Observable;

public class observer4 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        Wolf wolf =new Wolf("狼");
        Sheep sheep1 =new Sheep("羊1");
        Sheep sheep2 =new Sheep("羊2");
        Sheep sheep3 =new Sheep("羊3");
        //注册观察者，sheep1和2加入3不加入；
        wolf.addObserver(sheep1);
        wolf.addObserver(sheep2);
        String state="饿";
        wolf.shout(state);
	}

}
class Wolf extends Observable{//被观察者类
	private String name;
	Wolf(String name){
		this.name=name;
	}
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void shout(String state) {
		System.out.println(this.getName()+"shouting");
		this.setChanged(); this.notifyObservers(state);
	}
}
class Sheep implements Observer{

	private String state ="eating";
	private String name;
	
	public Sheep(String name) {
		super();
		this.name = name;
	}

	public String getState() {
		return state;
	}

	public void setState(String state) {
		this.state = state;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}


	@Override
	public void update(Observable arg0, Object arg1) {
		// TODO Auto-generated method stub
		Wolf w=(Wolf)arg0;
		System.out.println(w.getName()+"shouting and"+arg1+" "+this.getName()+"running------");
		setState("running");
	}
	
}

观察者模式的应用
1. 何时使用

  • 一个对象状态改变，所有的依赖对象都将得到通知

2. 方法

  • 使用面向对象技术

3. 优点

  • 观察者和被观察者是抽象耦合的
  • 建立了一套触发机制

4. 缺点

  • 如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间
  • 如果观察者和观察目标间有循环依赖，可能导致系统崩溃
  • 没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的

5. 使用场景

  • 关联行为场景
  • 事件多级触发场景
  • 跨系统的消息变换场景，如消息队列的处理机制


6. 应用实例

  • 手机丢了，委托别人给其他人发消息通知
  • 通知老师/老板来了
  • 拍卖，拍卖师观察最高标价，然后通知给其它竞价者竞价
  • 在一个目录下建立一个文件，会同时通知目录管理器增加目录，并通知磁盘减少空间，文件是被观察者，目录管理器和磁盘管理器是观察者
  • 猫叫了一声，吓着了老鼠，也惊到了主人，猫是被观察者，老鼠和人是观察者


7. 注意事项

  • 避免循环引用
  • 如果顺序执行，某一观察者错误会导致系统卡壳，一般采用异步方式
     
★漂浮ing☆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现观察者模式
01-20
要通知到需要了解该变化的类，Windows编程中经常用到的是发消息，要是没有Windows的消息机制的话，自己做一套消息机制倒是可以，但也是徒增了工作量，再次想到了设计模式中的观察者模式，也可以实现这个想法，具体...
Java 怎么实现观察者模式，有什么优缺点
徐师兄的博客
04-30 686
观察者模式是一种常用的设计模式，它可以用于在对象之间建立一对多的关系，当一个对象状态发生改变时，它的所有依赖对象都会收到通知并自动更新。在 Java 中，观察者模式可以使用 Java 自带的 Observer 和 Observable 类来实现。观察者模式的优点在于解耦，缺点在于可能会导致性能问题和循环引用的问题，需要谨慎使用。本文介绍了 Java 中观察者模式的实现方式和优缺点，并提供了相应的代码示例。
【设计模式-9】观察者模式
此处有码
12-11 797
参与者： Subject(抽象主题) 把所有观察者对象的引导保存到一个聚集里，每个抽象主题里边可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。 ConcreteSubject(具体主题) 实现抽象主题接口，当状态发生变化时，发送消息通知给聚集里观察者 Observer(抽象观察者) 为所有具体观察者定义一个接口，在得到主题通知时，更新自己。一...
什么是观察者模式？
m0_45861545的博客
11-02 5416
https://www.runoob.com/design-pattern/observer-pattern.html
设计模式第5讲——观察者模式（Observer）
让~学习~成为一种习惯（橡 皮 人の技术博客）
06-02 8476
观察者模式属于行为型模式。一、什么是观察者模式 二、特点 三、组成 四、应用场景4.1 生活场景4.2 程序场景 五、观察者模式实现5.0 UML类图5.1 Newspaper5.2 NewspaperImpl5.3 Subscriber5.4 SubscriberImpl5.5 测试
观察者模式1
08-08
2、目标与观察者之间建立了一套触发机制 1、目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用 2、当观察者对象很多时，通知的发布会花费很多时间，
PHP 设计模式之观察者模式介绍
10-28
观察者模式定义对象的一对多依赖,这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新!
iOS 设计模式 观察者模式
02-18
iOS 设计模式 观察者模式
三种观察者模式的C#实现
01-20
说起观察者模式，估计在园子里能搜出一堆来。所以写这篇博客的目的有两点: 　观察者模式是写松耦合代码的必备模式，重要性不言而喻，抛开代码层面，许多组件都采用了Publish-Subscribe模式，所以我想按照自己的理解...
第23章_观察者模式.ppt
03-31
在此，发生改变的对象称为观察目标，而被通知的对象称为观察者，一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系，可以根据需要增加和删除观察者，使得系统更易于扩展，这就是观察者模式的模式动机...
java观察者模式.doc
09-19
在设计一组依赖的对象与它们所依赖的对象之间一致（同步）的交流模型时，观察者模式（Observer Pattern）很有用。它可以使依赖对象的状态与它们所依赖的对象的状态保持同步。这组依赖的对象指的是观察者（Observer）...
观察者模式代码
03-27
观察模式可以用多种形式来写这里分别用了委托跟接口。 优点： 1、观察者和被观察者是抽象耦合的。...缺点： 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
观察者模式java
06-19
观察者模式java 应用场景如下 现在有一个销售各类的电子商务网站的购物车（Shopping Cart）系统。现在本网站进行打折，分别情况如下： 1. 对所有的教材类图书实行每本降价一元的折扣 2. 对连环画类图书提供7%的...
java设计模式-观察者模式
张钰杰杰杰杰杰的博客
04-24 1846
观察者模式介绍： 观察者模式（有时又被称为发布/订阅模式）是软件设计模式的一种。在此种模式中，一个目标对象管理所有相依于它的观察者对象，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实时事件处理系统。 简单案例： 假设猫是老鼠和狗的观察目标,老鼠和狗是观察者,猫叫老鼠跑,狗也跟着叫,使用观察者模式描述该过程 抽象目标类 MySubject MySubject是抽象目标类,在其中定义了一个ArrayList类型的集合observers,用于存储观察者对象,并
设计模式之观察者模式详解
weixin_45538589的博客
09-17 3458
观察者模式 (Observer Pattern) 又叫发布-订阅模式 (Publish/Subscribe)，定义一种一对多的依赖关系，一个主题对象 (被观察对象) 可被多个观察者对象同时监听，使得每当主题对象状态变化时，所有依赖于它的对象都会得到通知并被更新，属于行为型模式。 ​ 观察者模式的核心是将观察者与主题对象解耦，以类似于消息、广播发送的机制联动两者，使被观察者的变动能通知到感兴趣的观察者们，从而做出相应的响应
观察者模式(Observer) 简介
nvd11的专栏
12-31 9833
一, 观察者模式(Observer) 的定义 观察者模式: 定义了一种 1对多 的依赖关系, 让多个观察者对象同时监听1个主题对象. 这个主题对象在状态发生变化时, 会通知所有的观察者对象, 使它们能够同时更新自己. 稍微解释一下 这个1 对多 的依赖关系. 1对多 这个关键词我们常常在DB 表设计里提到, 但是这里的意思是有
Android观察者模式
最新发布
10-28
在Android中，观察者模式是一种常见的设计模式，它主要用于各种控件的监听。当一个控件的状态发生改变时，它会通知所有注册的观察者，观察者会立即响应并执行相应的操作。在Android中，我们通常使用匿名内部类来实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值