实例
建立一个关于气象站的应用，该系统由三个部分组成，气象站（获取数据的物理装置）、WeatherData对象和布告板（显示天气状况给用户看）。
该应用有以下几个要求：
1.WeatherData类具有getter方法，可以取得三个测量值。
2.当心的测量数据备妥时，measurementsChanged（）方法就会被调用（我们不在乎此方法是如何被调用的，我们只在乎它被调用了）
3.我们需要实现三个使用天气数据的布告板，一旦WeatherData有新的测量，这些布告板必须马上更新。
4.此系统必须可扩展，让其他开发人员建立定制的布告板，用户可以随心所欲地添加或删除任何布告板。
应用观察者模式
认识观察者模式：
用一个很贴近生活的例子就是报纸杂志和订阅的关系，我订阅一家出版社的报纸，只要他们出版社出版了新的报纸，就会给我送过来，当我不想看的时候，我只要取消订阅就可以了。
简言之：
出版者+订阅者=观察者模式
我们将出版者修改名称改为“主题”，订阅者改为“观察者”，可以得出下面观察者模式的类图。
定义观察者模式：
主题和观察者之间形成了一种1对多的关系，观察者依赖此主题，只要主题发生变化，观察者就会被通知。
松耦合的威力
当两个对象之间松耦合，它们依然可以交互，但是不太清楚彼此的细节。
观察者模式提供了一种对象设计，让主题和观察者之间松耦合。
为什么呢？
关于观察者的一切，主题只知道观察者实现了某个接口（也就是Observer接口）。主题不需要知道观察者的具体类是谁、做了些什么或其他任何细节。
任何时候我们都可以增加新的观察者。因为主题唯一依赖的东西是一个实现Observer接口的对象列表，所以我们可以随时增加观察者。事实上，在运行时我们可以用新的观察者取代现有的观察者，主题不会受到任何影响。同样的，也可以在任何时候删除某些观察者。
有新类型的观察者出现时，主题的代码不需要修改。假如我们有个新的具体类需要当观察者，我们不需要为了兼容新类型而修改主题的代码，所有要做的就是在新的类里实现此观察者接口，然后注册为观察者即可。主题不在乎别的，它只会发送通知给所有实现了观察者接口的对象。
我们可以独立地复用主题或观察者。如果我们在其他地方需要使用主题或观察者，可以轻易地复用，因为二者并非紧耦合。
改变主题或观察者其中一方，并不会影响另一方。因为两者是松耦合的，所以只要他们之间的接口仍被遵守，我们就可以自由地改变他们。
这里引出了一个设计原则： 为了交互对象之间的松耦合设计而努力。
根据这个原则，设计气象台的问题。
接下来用代码来实现
主题接口：
public interface Subject {
//这两个方法都需要一个观察者作为变量，该观察者是用来注册或被删除的。
public void registerObserver(Observer o);
public void removeObserver(Observer o);
//当主题状态改变时，这个方法会被调用，以通知所有的观察者。
public void notifyObservers();
}
观察者接口：
public interface Observer {
//当气象观测值改变时，主题会把这些状态值当作方法的参数，传送给观察者。
//所有的观察者都必须实现update()方法，以实现观察者接口。
public void update(float temp, float humidity, float pressure);
}
显示接口：
public interface DisplayElement {
//DisplayElement接口只包含了一个方法，也就是display()。当布告板需要
//显示时调用此方法。
public void display();
}
实现主题接口：
//WeatherData现在实现了Subject接口。
public class WeatherData implements Subject {
private ArrayList observers;
private float temperature;
private float humidity;
private float pressure;
public WeatherData() {
//ArrayList来纪录观察者，此ArrayList是在构造器中建立的
observers = new ArrayList();
}
public void registerObserver(Observer o) {
//当注册观察者时，我们只要把它加到ArrayList的后面即可。
observers.add(o);
}
public void removeObserver(Observer o) {
//同样地，当观察者想取消注册，我们把它从ArrayList中删除即可。
int i = observers.indexOf(o);
if (i >= 0) {
observers.remove(i);
}
}
public void notifyObservers() {
//在这里，我们把状态告诉每一个观察者。因为观察者都实现了update()
for (int i = 0; i < observers.size(); i++) {
Observer observer = (Observer)observers.get(i);
observer.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();
}
接下来建立其中一个布告板类：
//此布告板实现了Observer接口，所以可以从WeatherData对象中获得改变
//它也实现了DisplayElement接口，因为我们的API规定所有的布告板都必须实现此接口。
public class CurrentConditionsDisplay implements Observer, DisplayElement {
private float temperature;
private float humidity;
private Subject weatherData;
public CurrentConditionsDisplay(Subject weatherData) {
//构造器需要 weatherData对象（也就是主题）作为注册之用。
this.weatherData = weatherData;
weatherData.registerObserver(this);
}
public void update(float temperature, float humidity, float pressure) {
//当update()被调用时，我们把温度和湿度保存起来，然后调用display()。
this.temperature = temperature;
this.humidity = humidity;
display();
}
public void display() {
//display()方法就只是把最近的温度和湿度显示出来。
System.out.println("Current conditions: " + temperature
+ "F degrees and " + humidity + "% humidity");
}
}
整合测试：
public class WeatherStation {
public static void main(String[] args) {
WeatherData weatherData = new WeatherData();
CurrentConditionsDisplay currentDisplay =new CurrentConditionsDisplay(weatherData);
weatherData.setMeasurements(80, 65, 30.4f);
weatherData.setMeasurements(82, 70, 29.2f);
weatherData.setMeasurements(78, 90, 29.2f);
}
}
以上就实现了一种简单的观察者模式了，但是我们可以想想可以发现，主题是发现更新了数据之后，就将内容“推”给了观察者，推了什么内容，什么时候推，观察者都是不清楚的。那么这时我们想，能不能让观察者自由“拉”资源，需要什么资源，什么时候需要资源，观察者都可以自己决定。但是这种操作有一定的风险，意味着主题和观察者直接高耦合了，主题的数据也暴露了。
使用JAVA内置的观察者模式
Java内置的观察者模式如何运作
Java内置的观察者模式运作方式，和我们在气象站中的实现类似，但有一些小差异。最明显的差异是WeatherData（也就是我们的主题）现在扩展自Observable类，并继承到一些增加、删除、通知观察者的方法（以及其他的方法）。
利用内置的支持重做气象站
首先，把WeatherData改成使用java.util.Observable
//记得要导入（import）正确的Observer/Observable。
import java.util.Observable;
import java.util.Observer;
//我们现在正在继承Observable。
public class WeatherData extends Observable {
private float temperature;
private float humidity;
private float pressure;
public WeatherData() { }
//我们的构造器不再需要为了记住观察者们而建立数据结构了。
public void measurementsChanged() {
//在调用notifuObservers()之前，要先调用setChanged()来指示状态已经改变。
setChanged();
//注意：我们没有调用notifyObservers()传送数据对象，这表示我们采用的做法是“拉”。
notifyObservers();
}
public void setMeasurements(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
measurementsChanged();
}
//
public float getTemperature() {
return temperature;
}
public float getHumidity() {
return humidity;
}
public float getPressure() {
return pressure;
}
//这些并不是新方法，只是因为我们要使用“拉”的做法，所以才提醒你有这些方法。察者会利用这些方法取得WeatherData对象的状态。
}
重做布告板类
import java.util.Observable;
import java.util.Observer;
public class CurrentConditionsDisplay implements Observer, DisplayElement {
Observable observable;
private float temperature;
private float humidity;
public CurrentConditionsDisplay(Observable observable) {
//在构造器需要一Observable当参数，并将CurrentCondi- tionsDisplay对象登记成为观察者。
this.observable = observable;
observable.addObserver(this);
}
//改变update()方法，增加Observable和数据对象作为参数。
public void update(Observable obs, Object arg) {
if (obs instanceof WeatherData) {
WeatherData weatherData = (WeatherData)obs;
this.temperature = weatherData.getTemperature();
this.humidity = weatherData.getHumidity();
display();
}
//在 update()中，先确定可观察者属于WeatherData类型，然后利用 getter方法获取温度和湿度测量值，最后调用display()。
}
public void display() {
System.out.println("Current conditions: " + temperature
+ "F degrees and " + humidity + "% humidity");
}
}
java.util.Observable的黑暗面
使用内置的实现观察者模式的方法，违反了设计原则：针对接口编程，而非针对实现编程。因为观察者Observable是一个类，而不是一个接口，你必须设计一个类继承它。如果某类想同时具有Observable类和另一个超类的行为，就会陷入两难，毕竟Java不支持多重继承。这限制了Observable的复用潜力。
另外，Observable将关键的方法保护起来，如果你看看Observable API，你会发现setChanged()方法被保护起来了（被定义成protected）。那又怎么样呢？这意味着：除非你继承自Observable，否则你无法创建Observable实例并组合到你自己的对象中来。这个设计违反了第二个设计原则：“多用组合，少用继承”。
