观察者(observer)模式定义了对象之间的一对多依赖,这样一来,当一个对象改变状态时,它的所有依赖者都会收到通知并自动更新。
observer模式中有两个关键要素,一是Observer,一是Subject,
Subject就是被观察者,它一般是事件的来源,
Observer是观察者,它一般是事件发生的时候应该进行相应的操作的对象。
package org.kangsg219.intf;
public interface Subject {
public void registerObserver(Observer o);
public void removeObserver(Observer o);
public void notifyObservers();
}
package org.kangsg219.intf;
public interface Observer {
public void update(float temperature,float humidity,float pressure);
}
package org.kangsg219.intf;
public interface DisplayElement {
public void display();
}
package org.kangsg219.impl;
import java.util.ArrayList;
import java.util.List;
import org.kangsg219.intf.Observer;
import org.kangsg219.intf.Subject;
public class WeatherData implements Subject {
private List<Observer> observers;
private float temperature;
private float humidity;
private float pressure;
public WeatherData() {
observers = new ArrayList<Observer>();
}
public void registerObserver(Observer o) {
observers.add(o);
}
public void removeObserver(Observer o) {
int i=observers.indexOf(o);
if(i>=0){
observers.remove(i);
}
}
public void notifyObservers() {
for(int i=0;i<observers.size();i++){
Observer tempo=observers.get(i);
tempo.update(temperature, humidity, pressure);
}
}
public void measurementsChanged(){
notifyObservers();
}
public void setMeasurements(float temperature,float humidity,float pressure){
this.temperature=temperature;
this.humidity=humidity;
this.pressure=pressure;
measurementsChanged();
}
}
package org.kangsg219.impl;
import org.kangsg219.intf.DisplayElement;
import org.kangsg219.intf.Observer;
import org.kangsg219.intf.Subject;
public class CurrentConditionDisplay implements Observer,DisplayElement {
private float temperature;
private float humidity;
private float pressure;
@SuppressWarnings("unused")
private Subject weatherData;
public CurrentConditionDisplay(Subject weatherData){
this.weatherData=weatherData;
weatherData.registerObserver(this);
}
public void update(float temperature, float humidity, float pressure) {
this.temperature=temperature;
this.humidity=humidity;
this.pressure=pressure;
display();
}
public void display() {
System.out.println("CurrentConditionDisplay:");
System.out.println("temperature:"+temperature+" "+"humidity:"+humidity+" "+"pressure:"+pressure);
System.out.println("=============================================");
}
}
package org.kangsg219.impl;
import org.kangsg219.intf.DisplayElement;
import org.kangsg219.intf.Observer;
import org.kangsg219.intf.Subject;
public class CurrentConditionDisplay implements Observer,DisplayElement {
private float temperature;
private float humidity;
private float pressure;
@SuppressWarnings("unused")
private Subject weatherData;
public CurrentConditionDisplay(Subject weatherData){
this.weatherData=weatherData;
weatherData.registerObserver(this);
}
public void update(float temperature, float humidity, float pressure) {
this.temperature=temperature;
this.humidity=humidity;
this.pressure=pressure;
display();
}
public void display() {
System.out.println("CurrentConditionDisplay:");
System.out.println("temperature:"+temperature+" "+"humidity:"+humidity+" "+"pressure:"+pressure);
System.out.println("=============================================");
}
}
package org.kangsg219.impl;
import org.kangsg219.intf.DisplayElement;
import org.kangsg219.intf.Observer;
import org.kangsg219.intf.Subject;
public class StatisticsDisplay implements Observer, DisplayElement {
private float temperature;
private float humidity;
private float pressure;
@SuppressWarnings("unused")
private Subject weatherData;
public StatisticsDisplay(Subject weatherData){
this.weatherData=weatherData;
weatherData.registerObserver(this);
}
public void update(float temperature, float humidity, float pressure) {
this.temperature=temperature;
this.humidity=humidity;
this.pressure=pressure;
display();
}
public void display() {
System.out.println("StatisticsDisplay:");
System.out.println("temperature:"+temperature+" "+"humidity:"+humidity+" "+"pressure:"+pressure);
System.out.println("=============================================");
}
}
package org.kangsg219.test;
import org.kangsg219.impl.CurrentConditionDisplay;
import org.kangsg219.impl.ForecastDisplay;
import org.kangsg219.impl.StatisticsDisplay;
import org.kangsg219.impl.WeatherData;
public class WeatherStation {
public static void main(String[] args) {
WeatherData weatherData = new WeatherData();
CurrentConditionDisplay ccd=new CurrentConditionDisplay(weatherData);
new StatisticsDisplay(weatherData);
new ForecastDisplay(weatherData);
weatherData.setMeasurements(33, 30, 30.4F);
weatherData.removeObserver(ccd);
weatherData.setMeasurements(34, 35, 30.4F);
}
}
java API中内置了观察者模式
package org.kangsg219.intf;
import java.util.Observer;
public interface IObserver extends Observer {
public void display();
}
package org.kangsg219.impl;
import java.util.Observable;
public class WeatherData2 extends Observable {
private float temperature;
private float humidity;
private float pressure;
public void measurementsChanged(){
setChanged();
System.out.println("before notifyObservers,hasChanged="+hasChanged());
notifyObservers();
System.out.println("after notifyObservers,hasChanged="+hasChanged());
}
public void setMeasurements(float temperature,float humidity,float pressure){
this.temperature=temperature;
this.humidity=humidity;
this.pressure=pressure;
measurementsChanged();
}
public float getHumidity() {
return humidity;
}
public float getPressure() {
return pressure;
}
public float getTemperature() {
return temperature;
}
}
package org.kangsg219.impl;
import java.util.Observable;
import org.kangsg219.intf.IObserver;
public class WeatherDisplay implements IObserver {
private float temperature;
private float humidity;
private float pressure;
@SuppressWarnings("unused")
private Observable observerable;
public WeatherDisplay(Observable observerable){
this.observerable=observerable;
observerable.addObserver(this);
}
public void update(Observable o, Object arg) {
if(o instanceof WeatherData2){
WeatherData2 weatherdata2=(WeatherData2)o;
this.humidity=weatherdata2.getHumidity();
this.temperature=weatherdata2.getTemperature();
this.pressure=weatherdata2.getPressure();
display();
}
}
public void display(){
System.out.println("WeatherDisplay:");
System.out.println("temperature:"+temperature+" "+"humidity:"+humidity+" "+"pressure:"+pressure);
System.out.println("=============================================");
}
}
package org.kangsg219.test;
import org.kangsg219.impl.WeatherData2;
import org.kangsg219.impl.WeatherDisplay;
public class WeatherStation2 {
public static void main(String[] args) {
WeatherData2 weatherdata2=new WeatherData2();
WeatherDisplay wdisplay=new WeatherDisplay(weatherdata2);
new WeatherDisplay(weatherdata2);
weatherdata2.setMeasurements(30, 30, 30F);
weatherdata2.deleteObserver(wdisplay);
weatherdata2.setMeasurements(33, 33, 33.3F);
}
}
java api 中内置的观察者模式是怎么实现的我们并不清楚,它对结果的输出顺序我们也无法把握,有必要的话建议自己实现这个模式!
分享到:
相关推荐
主要为大家详细介绍了Java学习笔记之观察者模式的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
总的来说,HeadFirst设计模式的学习笔记2关于观察者模式的演示,旨在帮助开发者理解如何使用观察者模式来构建可扩展的系统。通过实际的代码示例,我们可以更深入地掌握这一模式,并将其应用到日常开发中,提升代码的...
在Head First的观察者模式学习笔记中,我们可以深入理解这个模式的原理和应用。首先,观察者模式涉及到两个主要的角色:主题(Subject)和观察者(Observer)。主题是被观察的对象,它可以是任何具有可变状态的对象...
在这个“设计模式之美”的学习笔记中,我们将探讨一些主要的设计模式,以及它们在实际开发中的应用。 首先,我们从创建型模式开始。这类模式主要用于对象的创建,如单例模式(Singleton)、工厂模式(Factory ...
- 观察者模式定义了一种一对多的依赖关系,让多个观察对象同时监听某一个主题对象。当这个主题对象的状态发生变化时,会通知所有观察者对象,使它们能够自动更新自己。 - **类图**: - 包含主题接口和观察者接口...
本学习笔记将重点关注“观察者模式”,这是一种行为设计模式,用于在对象之间定义一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。 观察者模式的主要组成部分包括...
Java 线程学习笔记 Java 线程创建有两种方法: 1. 继承 Thread 类,重写 run 方法:通过继承 Thread 类并重写 run 方法来创建线程,这种方法可以使线程具有自己的执行逻辑。 2. 实现 Runnable 接口:通过实现 ...
6. **观察者模式**:定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。Java中的`Observer`和`Observable`接口就是这种模式的体现。 7. **装饰器模式**:...
设计模式是解决常见编程问题的模板,如单例模式、工厂模式和观察者模式。最后,笔记可能会介绍Java标准库的一些重要部分,如JDBC(Java数据库连接)用于数据库操作,或者Swing和JavaFX用于构建图形用户界面。 每道...
设计模式通常分为三类:创建型模式(如工厂模式、单例模式、建造者模式)、结构型模式(如适配器模式、装饰器模式、代理模式)和行为型模式(如策略模式、观察者模式、迭代器模式)。每种模式都有其特定的应用场景...
9. **设计模式**:学习和应用常见的设计模式(如工厂模式、单例模式、观察者模式等)能提高代码的可读性和可维护性。 10. **调试技巧**:学会使用调试工具,如GDB或IDE内置的调试器,可以帮助快速定位和解决问题。 ...
在《深入浅出设计模式》的学习笔记中,我们可以看到几种关键的设计模式及其应用,包括策略模式、观察者模式、装饰者模式、工厂模式和抽象工厂模式。 1. **策略模式**: - 策略模式的核心在于将算法族封装在独立的...
7. **观察者模式**:定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。 8. **适配器模式**:将一个类的接口转换成客户希望的另一个接口,使得原本由于接口...
7. **设计模式**:介绍常见的设计模式,如单例、工厂、装饰器、观察者等,帮助提升代码的复用性和可维护性。 8. **反射机制**:探讨Java反射API的使用,包括动态获取类信息、创建对象、调用方法等功能,这对于理解...
16. **观察者模式**(订阅者模式):定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。 17. **命令模式**:将请求封装为一个对象,以便使用不同的请求、...
3. **观察者模式(Observer Pattern)**:Observable.java和QuackCounter.java可能与观察者模式相关。观察者模式定义了对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知...
16. **设计模式**:可能包含常见的23种设计模式,如单例,工厂,观察者,装饰器,适配器等模式的应用场景和实现。 17. **JVM内部机制**:虚拟机内存结构,类加载机制,字节码执行,性能优化等方面的知识。 这份...
### 设计模式学习笔记 #### 引言 设计模式(Design Patterns)是在软件设计领域内广泛应用的一种实践指南,它提供了一系列解决常见问题的方案。设计模式可以被理解为面向对象软件设计的经验总结,是对特定面向对象...
11. **设计模式**:介绍常见的设计模式,如工厂模式、单例模式、观察者模式等,以及如何在实际开发中应用它们。 12. **Spring框架**:作为良葛格另一部著作的主题,Spring框架的基本概念、依赖注入、AOP(面向切面...