观察者模式

　　定义如下。 　　观察者模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听某个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自己更新自己。 　　一开始我们可能写出下面这样的代码： 　　被观察者的代码（就是上面说的某个主题对象）：

import java.util.LinkedList; import java.util.List; public class ConcreteObservable { private List<ConcreteObserver> mConcreteObserverList; public ConcreteObservable() { mConcreteObserverList = new LinkedList<>(); } public void addObserver(ConcreteObserver observer) { mConcreteObserverList.add(observer); } public void deleteObserver(ConcreteObserver observer) { mConcreteObserverList.remove(observer); } public void notifyObservers() { for (int i = 0;i < mConcreteObserverList.size();i++) { mConcreteObserverList.get(i).update(this); } } }

　　观察者的代码：

public class ConcreteObserver { public void update(ConcreteObservable observable) { System.out.println(this + "说：" + observable + "有通知了。"); } }

　　测试代码：

public class Test1 { public static void main(String[] args) { ConcreteObservable concreteObservable = new ConcreteObservable(); ConcreteObserver concreteObserver1 = new ConcreteObserver(); ConcreteObserver concreteObserver2 = new ConcreteObserver(); ConcreteObserver concreteObserver3 = new ConcreteObserver(); concreteObservable.addObserver(concreteObserver1); concreteObservable.addObserver(concreteObserver2); concreteObservable.addObserver(concreteObserver3); concreteObservable.notifyObservers(); } }

　　结果:

ConcreteObserver@5cad8086说：ConcreteObservable@6e0be858有通知了。 ConcreteObserver@61bbe9ba说：ConcreteObservable@6e0be858有通知了。 ConcreteObserver@610455d6说：ConcreteObservable@6e0be858有通知了。

　　上面的代码几乎没有可扩展性，比如如果观察者不只一种，有非常多种，而它们可能就是有个update()方法一样。所以可以用个接口，将观察者抽象出来，具体改动后的代码如下： 　　抽象观察者接口：

public interface Observer { void update(ConcreteObservable observable); }

　　具体观察者一：

public class ConcreteObserverOne implements Observer { @Override public void update(ConcreteObservable observable) { System.out.println(this + "说：" + observable + "发通知了，我要去搬砖了。"); } }

　　具体观察者二：

public class ConcreteObserverTwo implements Observer { @Override public void update(ConcreteObservable observable) { System.out.println(this + "说：" + observable + "发通知了，我要去打酱油了。"); } }

　　具体观察者三：

public class ConcreteObserverThree implements Observer { @Override public void update(ConcreteObservable observable) { System.out.println(this + "说：" + observable + "发通知了，我要去打睡觉了。"); } }

　　被观察者的代码：

import java.util.LinkedList; import java.util.List; public class ConcreteObservableOne implements Observable { private List<Observer> mConcreteObserverList; public ConcreteObservableOne() { mConcreteObserverList = new LinkedList<>(); } public void addObserver(Observer observer) { mConcreteObserverList.add(observer); } public void deleteObserver(Observer observer) { mConcreteObserverList.remove(observer); } public void notifyObservers() { for (int i = 0;i < mConcreteObserverList.size();i++) { mConcreteObserverList.get(i).update(this); } } }

　　测试代码：

public class Test1 { public static void main(String[] args) { ConcreteObservable concreteObservable = new ConcreteObservable(); Observer concreteObserverOne = new ConcreteObserverOne(); Observer concreteObserverTwo = new ConcreteObserverTwo(); Observer concreteObserverThree = new ConcreteObserverThree(); concreteObservable.addObserver(concreteObserverOne); concreteObservable.addObserver(concreteObserverTwo); concreteObservable.addObserver(concreteObserverThree); concreteObservable.notifyObservers(); } }

　　结果：

ConcreteObserverOne@5cad8086说：ConcreteObservable@6e0be858发通知了，我要去搬砖了。 ConcreteObserverTwo@61bbe9ba说：ConcreteObservable@6e0be858发通知了，我要去打酱油了。 ConcreteObserverThree@610455d6说：ConcreteObservable@6e0be858发通知了，我要去打睡觉了。

　　当然，你还可以更彻底点，再用接口弄个抽象的被观察者Observable：

public interface Observable { void addObserver(Observer observer); void deleteObserver(Observer observer); void notifyObservers(); }

　　剩下的代码就不贴了，上面看懂了，应该很容易写了。 　　 　　这样就很好的对代码进行解耦了，也很好的体现了依赖倒置原则。（所谓依赖倒置原则（Dependence Inversion Principle ）就是要依赖于抽象，不要依赖于具体。）