headFirst设计模式——观察者模式
作者：互联网
一、介绍
观察者（Observer）模式可以帮你的对象知悉现况，不会错过该对象感兴趣的事。
对象甚至在运行时可决定是否要继续被通知。以及一对多关系，和松耦合。
有了观察者，你将会消息灵通。
观察者模式定义了对象之间的一对多依赖，这样一来当一个对象改变状态时，
它的所有依赖着都会收到通知并自动更新。
实现观察者模式的方法不止一种，但是以包含Subject和Observer接口的类设计的做法最常见。
二、引入
恭喜贵公司获选为敝公司建立下一代Internet气象观测站！
该气象站必须建立在我们专利申请中的WeatherData对象 上，由WeatherData对象负责追踪目前的天气状况（温度、 湿度、气压）。我们希望贵公司能建立一个应用，有三种 布告板，分别显示目前的状况、气象统计及简单的预报。 当WeatherObject对象获得最新的测量数据时，三种布告板 必须实时更新。 而且，这是一个可以扩展的气象站，Weather-O-Rama气象 站希望公布一组API，好让其他开发人员可以写出自己的 气象布告板，并插入此应用中。我们希望贵公司能提供这 样的API。 Weather-O-Rama气象站有很好的商业营运模式：一旦客 户上钩，他们使用每个布告板都要付钱。最好的部分就是， 为了感谢贵公司建立此系统，我们将以公司的认股权支付 你。 我们期待看到你的设计和应用的alpha版本。
WeatherData对象知道如何跟物理气象站联系，以取得更新的数据。WeatherData对象随即更新三个布告板的显示：目前状况（温度、湿度、气压）、气象统计和天气预报。
我们的工作就是建立一个应用，利用WeatherData对象取得数据，并更新三个布告板：目前状况、气象统计和天气预报。
报纸的订阅 出版者+订阅者=观察者模式 出版者改称为“主题”（Subject），订阅者改称为“观察者”（Observe）。
设计原则： 1、为了交互对象之间的松耦合设计而努力。 松耦合的设计之所以能让我们建立有弹性的OO系统，能够应对变化，是因为对象之间的互相依赖降到了最低。 三、实现
Java为观察者模式提供了内置支持，但是许多时候，自己建立这一切会更具弹性。 主题
1 public interface Subject {
2
3 public void registerObserver(Observer o);
4
5 public void removeObserver(Observer o);
6
7 public void notifyObservers();
8 }
主题实现类
1 public class WeatherData implements Subject{
2 private ArrayList<Observer> observers;
3 private float temperature;
4 private float humidity;
5 private float pressure;
6
7 // 我们加上一个ArrayList来纪录观察者，此ArrayList是在构造器中建立的。
8 public WeatherData(){
9 observers = new ArrayList<Observer>();
10 }
11
12 @Override
13 public void registerObserver(Observer o) {
14 observers.add(o);
15 }
16
17 @Override
18 public void removeObserver(Observer o) {
19 int i = observers.indexOf(o);
20 if (i >= 0){
21 observers.remove(i);
22 }
23 }
24
25 @Override
26 public void notifyObservers() {
27 // 在这里，我们把状态告诉每一个观察者。因为观察者都实现了update()，所以我们知道如何通知它们。
28 for (int i = 0; i < observers.size(); i++) {
29 Observer observer = observers.get(i);
30 observer.update(temperature, humidity, pressure);
31 }
32 }
33
34 public void measurementsChanged(){
35 // 当从气象站得到更新观测值 时，我们通知观察者。
36 notifyObservers();
37 }
38
39 public void setMeasurements(float temperature, float humidity, float pressure) {//模拟从气象站收到数据
40 this.temperature = temperature;
41 this.humidity = humidity;
42 this.pressure = pressure;
43 measurementsChanged();
44 }
45
46 }
观察者
1 public interface Observer {
2
3 // 暗示：这些观测值的种类和个数在未来有可能改变吗？如果以后会改变，这些变化是否被很好地封装？或者是需要修改许多代码才能办到？
4 public void update(float temp, float humidity, float pressure);
5 }
每个观察者必须实现的接口
1 public interface DisplayElement {
2
3 public void display();
4 }
观察者实现类
1 public class CurrentConditionsDisplay implements DisplayElement, Observer {
2 private float temperature;
3 private float humidity;
4 private Subject weatherData;
5
6 // 构造器需要 weatherData对象（也就是主题）作为注册用。
7 public CurrentConditionsDisplay(Subject weatherData) {
8 this.weatherData = weatherData;
9 weatherData.registerObserver(this);
10 }
11
12 @Override
13 public void update(float temperature, float humidity, float pressure) {
14 this.temperature = temperature;
15 this.humidity = humidity;
16 display(); // 这里并不是调用display()最合适的地方。
17 }
18
19 @Override
20 public void display() {
21 System.out.println("Current conditions: "+ temperature +
22 "F degrees and " + humidity +"%humidity");
23 }
24
25 }
测试
1 public class WeatherStation {
2
3 public static void main(String[] args) {
4 // 主题
5 WeatherData weatherData = new WeatherData();
6 // 订阅者 向 主题 注册
7 CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData); // Subject引用可能在取消订阅时用到。
8
9 // 模拟从气象站取得数据
10 weatherData.setMeasurements(80, 65, 30.4f); // Current conditions: 80.0F degrees and 65.0%humidity
11 }
12 }
四、变化
JohnnyAHurricane（Weather-O-Rama气象站的CEO）刚刚来电告知，他们还需要酷热指数（HeatIndex）布告板，这是不可或缺的。
细节如下：
酷热指数是一个结合温度和湿度的指数，用来显示人的温度感受。可以利用温度T和相对湿度RH套用下面的公式来计算酷热指数：
一个关于温度和相对湿度的计算公式。
新注册一个观察者HeadIndexDisplay
1 public class HeatIndexDisplay implements Observer, DisplayElement {
2 private float tempreture;
3 private float humidity;
4 private Subject weatherData;
5
6 public HeatIndexDisplay(Subject weatherData) {
7 this.weatherData = weatherData;
8 weatherData.registerObserver(this);
9 }
10
11 @Override
12 public void display() {
13 float T = tempreture;
14 float RH = humidity;
15 // 公式不对
16 float heatIndex =
17 (float) (16.923 + 1.85212 * 10-1 * T + 5.37941 * RH - 1.00254 * 10-1 * T
18 * RH + 9.41695 * 10-3 * T*T + 7.28898 * 10-3 * RH*RH + 3.45372 * 10-4
19 * T*T * RH - 8.14971 * 10-4 * T * RH*RH + 1.02102 * 10-5 * T*T * RH*RH -
20 3.8646 * 10-5 * T*T*T + 2.91583 * 10-5 * RH*RH*RH + 1.42721 * 10-6 * T*T*T * RH
21 + 1.97483 * 10-7 * T * RH*RH*RH - 2.18429 * 10-8 * T*T*T * RH*RH + 8.43296 *
22 10-10 * T*T * RH*RH*RH - 4.81975 * 10-11 * T*T*T * RH*RH*RH);
23
24 System.out.println("HeadIndex is" + heatIndex);
25 }
26
27 @Override
28 public void update(float tempreture, float humidity, float pressure) {
29 // TODO Auto-generated method stub
30 this.tempreture = tempreture;
31 this.humidity = humidity;
32 display();
33
34 }
35
36 }
五、讨论
主题和观察者就 使观察者获得状态信息的正确方式： 1、主题主动推送数据 方便不需要再去拉数据，但是有时候不需要的也会推送过来。 2、观察者主动取数据 用时去取，主题需要封装、再开放setter避免暴露过多信息。 java内置Observer这两种都支持。 java.util包（package）内包含最基本的Observer接口与Observable类，这和Subject接口与Observer接口很相似。 Observer接口与Observable类使用上更方便，因为许多功能都已经事先准备好了。 甚至可以使用推（push）或拉（pull）的方式传送数据。
setChanged()方法的作用：
setChanged()方法可以让你在更新观察者时，有更多的弹性，你可以更适当地通知观察者。
比方说，如果没有setChanged()方法，我们的气象站测量是如此敏锐，以致于温度计读数每十分之一度就会更新，
这会造成WeatherData对象持续不断地通知观察者，我们并不希望看到这样的事情发生。
如果我们希望半度以上才更新，就可以在温度差距到达半度时，调用setChanged()，进行有效的更新。
主题 1 public class WeatherData extends Observable{
2
3 private float temperature;
4 private float humidity;
5 private float pressure;
6
7 // "拉"察者会利用这些方法取得WeatherData对象的状态
8 public float getTemperature() {
9 return temperature;
10 }
11
12 public float getHumidity() {
13 return humidity;
14 }
15
16 public float getPressure() {
17 return pressure;
18 }
19
20 public void setMeasurements(float temperature, float humidity, float pressure) {
21 this.temperature = temperature;
22 this.humidity = humidity;
23 this.pressure = pressure;
24 measurementsChanged();
25 }
26
27 public void measurementsChanged(){
28 setChanged();
29 notifyObservers(); //注意：我们没有调用notifyObservers()传送数据对象，这表示我们采用的做法是“拉”。
30 }
31 }
观察者
1 import java.util.Observable;
2 import java.util.Observer;
3
4 public class CurrentConditionsDisplay implements Observer,DisplayElement {
5
6 private float temperature;
7 private float humidity;
8 Observable o;
9
10 public CurrentConditionsDisplay(Observable o) {
11 this.o = o;
12 o.addObserver(this);
13 }
14
15 @Override
16 public void update(Observable obs, Object arg) {
17 if(obs instanceof WeatherData){
18 WeatherData weatherData = (WeatherData) obs;
19 this.temperature = weatherData.getTemperature();
20 this.humidity = weatherData.getHumidity();
21 display();
22 }
23 }
24 @Override
25 public void display() {
26 System.out.println("Current conditions: "+ temperature +
27 "F degrees and " + humidity +"%humidity");
28 }
29
30 }
内置观察者模式的问题：
1、通知观察者的次序不一定是其注册的次序。 可以确定的是，如果我们的代码依赖之前的次序，就是错的。 一旦观察者/可观察者的实现有所改变，通知次序就会改变，很可能产生错误的结果，也不是我们所认为的松耦合。 2、java.util.Observable是一个类而不是一个接口 如果某类想同时具有Observable类和另一个超类的行为，就会陷入两难，毕竟Java不支持多重继承。 这限制了Observable的复用潜力（而增加复用潜力不正是我们使用模式最原始的动机吗？）。 再者，因为没有Observable接口，所以你无法建立自己的实现，和Java内置的Observer API搭配使用。 3、Observable将关键的方法保护起来 如果你看看Observable API，你会发现setChanged()方法被保护起来了（被定义成protected）。 这意味着：除非你继承自Observable，否则你无法创建Observable实例并组合到你自己的对象中来。 这个设计违反了第二个设计原则：“多用组合，少用继承”。 六、总结 观察者模式定义了对象之间一对多的关系。 主题（也就是可观察者）用一个共同的接口来更新观察者。 观察者和可观察者之间用松耦合方式结合（loosecoupling），可观察者不知道观察者的细节，只知道观察者实现了观察者接口。 使用此模式时，你可从被观察者处推（push）或拉（pull）数据（然而，推得方式被认为更“正确”）。 有多个观察者时，不可以依赖特定的通知顺序。 Java有多种观察者模式的实现，包括了通用的java.util.Observable。 要注意java.util.Observable所带来的的一些问题。 如果有必要的话，可以实现自己的Observable。 设计原则： 1、封装变化 2、多用组合，少用继承 3、针对接口编程，不针对实现编程 4、为交互之间的松耦合设计儿努力 // 新原则 『观察者模式』Obverse Pattern 在对象之间定义一对多的依赖，这样一来，当一个对象改变状态，依赖它的其他对象都会收到通知，并自动更新。 一个新的模式，以松耦合方式在一系列对象之间沟通状态。我们目前还没看到观察者模式的代表人物——MVC。标签：headFirst,10,float,观察者,humidity,设计模式,RH,public 来源： https://www.cnblogs.com/onroad2019/p/12895336.html