一般观察者模式用在一对多的关系中,当一个对象发生改变时,依赖这个对象的其他对象就要自动做出改变。
气象站例子
这个气象站系统中包含三个部分,气象站代表获取实际气象数据的物理装置,WeatherData对象可以追踪来自气象站的数据,并更新布告板,布告板是展示给用户看的。
WeatherData对象知道如何跟物理气象站联系,拿到相应数据之后,会更新布告板,
如果我们写代码的话,可能会写成如下样子:
public class WeatherData {
public void measurementsChanged(){
//从气象站获得相关温度、湿度、气压等信息
float temp = getTemperature();
float humidity = getHumidity();
float pressure = getPressure();
//更新三个布告板的相关天气信息
currentConditionDisplay.update(temp, humidity, pressure);
statisticDisplay.update(temp, humidity, pressure);
forecastDisplay.update(temp, humidity, pressure);
}
}
那这样做有什么不好的地方呢?
1、三个update方法看起来应该像个统一的接口,所以要封装起来
2、三个update方法针对实现编程,会导致我们以后再增加或者删除布告板时必须修改程序。
认识观察者模式
举个例子,我们向某家报社订阅报纸,只要他们有新闻出版,就会给你送新的报纸来。如果我们取消订阅的话,报社就不会给我们送新的报纸过来。会有很多订阅者都向这个报社订阅报纸,而且这些订阅者都可以取消订阅关系。
出版者+订阅者= 观察者模式
定义观察者模式
观察者定义了对象之间的一对多依赖,这样一来,当一个对象改变状态时,它的所有依赖都会收到通知并自动更新。
优点
1、关于观察者的一切,主题只知道贯彻着实现了某个接口(也就是Observer接口)。主题不需要知道观察者的具体类是谁,做了些什么或者其他什么细节。
2、任何时候我们都可以增加新的观察者,因为主题唯一依赖的东西是一个实现Observer接口的对象列表,所以我们可以随时增加和删除观察者。
3、有新的类型的观察者出现的时候,我们不需要改变主题的代码,所要做的就是在新的类里面实现观察者的接口。
4、可以独立复用观察者这主题。
气象站代码
Subject.java
public interface Subject {
public void registerObserver(Observer observer);
public void removeObserver(Observer o);
public void notifyObservers();
}
Observer.java
public interface Observer {
public void update(float temp, float humidity, float pressure);
}
DisplayElement.java //用来展示数据
public interface DisplayElement {
public void display();
}
WeatherData.java //主题
import java.util.ArrayList;
public class WeatherData implements Subject{
private float temprature;
private float humidity;
private float pressure;
private ArrayList observers;
public WeatherData(){
observers = new ArrayList();
}
public void measurementsChanged(){//更新观察者
notifyObservers();
}
public void setMeasurements(float temprature, float humidity, float pressure){
this.temprature = temprature;
this.humidity = humidity;
this.pressure = pressure;
measurementsChanged();
}
@Override
public void registerObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer o) {
int i = observers.indexOf(o);
if (i >= 0){
observers.remove(o);
}
}
@Override
public void notifyObservers() {
for (int i = 0; i < observers.size(); i++){
Observer observer = (Observer) observers.get(i);
observer.update(temprature, humidity, pressure);
}
}
}
CurrentConditionsDisplay.java // 观察者
public class CurrentConditionsDisplay implements Observer, DisplayElement {
public CurrentConditionsDisplay(Subject weatherData){
this.weatherData = weatherData;
weatherData.registerObserver(this);
}
private float temperature;
private float humidity;
private float pressure;
private Subject weatherData;
@Override
public void display() {
System.out.println("Current conditions: +" + temperature + " F degrees and" + humidity +"% humidity");
}
@Override
public void update(float temp, float humidity, float pressure) {
this.temperature = temp;
this.humidity = humidity;
this.pressure = pressure;
display();
}
}
WeatherStation.java //测试方法
public class WeatherStation {
public static void main(String [] args){
WeatherData weatherData = new WeatherData();
CurrentConditionsDisplay currentConditionsDisplay = new CurrentConditionsDisplay(weatherData);
weatherData.setMeasurements(80, 65, 30.4f);
}
}
java中的实现方法
代码中我们的主题将自己的主题主动推送给观察者,当然还有另外一种方式,就是观察者根据自己的需求拉取主题的数据。 两种方式都有各自的优缺点。 Java内置的观察者模式同时支持者两种。
Java中相对于我们刚才的实现有几点不同,
1、java中的主题叫Observable,观察者叫Observer。
2、Observable并不是一个接口,而是一个类。这样会有几个问题,因为Observable是个类,所以你必须设计一个类来继承他。如果某类想同时具有Observable类和另一个超类的行为,就会陷入两难,毕竟java不支持多继承。