观察者模式的定义：
定义了对象之间的一对多的依赖，这样一来，当一个对象改变时，它的所有的依赖者都会收到通知并自动更新。
观察者模式的类图：
根据类图自定义主题、观察者接口：
package observer;/** * 主题接口 * @author 发挥哥 * */public interface Subject { /** * 注册观察者 * @param observer 观察者对象 */ void registerObserver(Observer observer); /** * 移除观察者 * @param observer 观察者对象 */ void removeObserver(Observer observer); /** * 通知所有观察者 */ void notifyObservers();} package observer;/** * 观察者接口 * @author 发挥哥 * */public interface Observer { /** * 主题通知所有观察者，执行该方法 * @param msg */ void update(String msg);} 创建主题类和观察者类：
package observer;import java.util.ArrayList;import java.util.List;import observer.Subject;/** * 自定义主题类，实现自定义主题接口 * @author 发挥哥 * */public class TestSubject implements Subject { /** * 所有注册到该主题的观察者 */ private List observers=new ArrayList<>(); /** * 主题的状态 */ private String msg; @Override public void registerObserver(Observer observer) { // TODO Auto-generated method stub if(observers!=null&&observer!=null) observers.add(observer); } @Override public void removeObserver(Observer observer) { // TODO Auto-generated method stub if(observers.contains(observer)) { observers.remove(observer); } } @Override public void notifyObservers() { // TODO Auto-generated method stub observers.stream().forEach(observer->{ observer.update("主题更新了，大家注意:"+this.msg); }); } /** * 编辑主题的状态后，通知所有观察者 * @param msg */ public void editMsg(String msg) { this.msg = msg; notifyObservers(); }} package observer;/** * 观察者1 * @author 发挥哥 * */public class Test1Observer implements Observer { /** * 创建观察者对象时，将其注册到指定的主题 * @param subject */ public Test1Observer(Subject subject) { subject.registerObserver(this); } /** * 当主题状态变化时，通过调用该方法通知观察者 */ @Override public void update(String msg) { // TODO Auto-generated method stub System.out.println(this.getClass().getName()+"收到主题发来的消息："+msg); }} package observer;/** * 观察者2（仅为测试，实现与观察者1一样） * @author 发挥哥 * */public class Test2Observer implements Observer { public Test2Observer(Subject subject) { subject.registerObserver(this); } @Override public void update(String msg) { // TODO Auto-generated method stub System.out.println(this.getClass().getName()+"收到主题发来的消息："+msg); }} 创建测试方法：
package observer;public class TestMain { public static void main(String[] args) { //创建主题 TestSubject subject=new TestSubject(); //创建观察者1并注册到主题 Observer observer1=new Test1Observer(subject); //创建观察者2并注册到主题 Observer observer2=new Test2Observer(subject); //主题进行2次状态修改 subject.editMsg("第一次调整！"); subject.editMsg("第二次调整！"); }} 测试结果如下：
observer.Test1Observer收到主题发来的消息：主题更新了，大家注意:第一次调整！
observer.Test2Observer收到主题发来的消息：主题更新了，大家注意:第一次调整！ observer.Test1Observer收到主题发来的消息：主题更新了，大家注意:第二次调整！ observer.Test2Observer收到主题发来的消息：主题更新了，大家注意:第二次调整！
以上是自定义主题和观察者接口及其实现，JDK中已经帮我们实现了观察者模式，借助于java.util.Observable和java.util.Observer：
package java.util;public class Observable { private boolean changed = false; private Vector obs; public Observable() { obs = new Vector<>(); } public synchronized void addObserver(Observer o) { if (o == null) throw new NullPointerException(); if (!obs.contains(o)) { obs.addElement(o); } } public synchronized void deleteObserver(Observer o) { obs.removeElement(o); } public void notifyObservers() { notifyObservers(null); } public void notifyObservers(Object arg) { Object[] arrLocal; synchronized (this) { if (!changed) return; arrLocal = obs.toArray(); clearChanged(); } for (int i = arrLocal.length-1; i>=0; i--) ((Observer)arrLocal[i]).update(this, arg); } public synchronized void deleteObservers() { obs.removeAllElements(); } protected synchronized void setChanged() { changed = true; } protected synchronized void clearChanged() { changed = false; } public synchronized boolean hasChanged() { return changed; } public synchronized int countObservers() { return obs.size(); }} package java.util;public interface Observer { void update(Observable o, Object arg);} 类java.util.Observable和接口java.util.Observer比较简单，直接借此创建主题和观察者类：
package observer.jdk;import java.util.Observable;/** * 主题1 * @author 发挥哥 * */public class MySubject extends Observable { private String msg; /** * 编辑主题消息，并将变动标志置true，通知所有观察者，再将标志置false * @param msg */ public void editMsg(String msg) { if(msg==null) { this.msg = msg; setChanged(); notifyObservers("主题将消息置空！"); clearChanged(); return; } if(this.msg!=null&&msg!=null&&this.msg.equals(msg)) { return; } this.msg = msg; setChanged(); notifyObservers("主题更新消息："+this.msg); clearChanged(); }} package observer.jdk;import java.util.Observable;/** * 主题2（仅为测试，与观察者1实现一样） * @author 发挥哥 * */public class OtherSubject extends Observable { private String msg; public void editMsg(String msg) { if(msg==null) { this.msg = msg; setChanged(); notifyObservers("主题将消息置空！"); clearChanged(); return; } if(this.msg!=null&&msg!=null&&this.msg.equals(msg)) { return; } this.msg = msg; setChanged(); notifyObservers("主题更新消息："+this.msg); clearChanged(); }} package observer.jdk;import java.util.Observable;import java.util.Observer;/** * 观察者 * @author 发挥哥 * */public class MyObserver implements Observer { /** * 通过该方法将观察者自己注册到主题 * @param observable */ public void registerToSubject(Observable observable) { observable.addObserver(this); } @Override public void update(Observable o, Object arg) { System.out.println(this.getClass().getName()+"收到主题"+o.getClass().getName()+"更新消息："+arg); }} 编写测试方法：
package observer.jdk;public class MyTest { public static void main(String[] args) { //创建主题1、主题2 MySubject subject1=new MySubject(); OtherSubject subject2=new OtherSubject(); //创建观察者 MyObserver observer=new MyObserver(); //将观察者注册到主题1、主题2 observer.registerToSubject(subject1); observer.registerToSubject(subject2); //主题1、主题2分别更新状态 subject1.editMsg("主题一更新"); subject2.editMsg("主题二更新"); }} 测试结果如下：
observer.jdk.MyObserver收到主题observer.jdk.MySubject更新消息：主题更新消息：主题一更新
observer.jdk.MyObserver收到主题observer.jdk.OtherSubject更新消息：主题更新消息：主题二更新
比较好的观察者模式应用是微信公众号，公众号就是我们的主题，粉丝就是观察者。功能如下：
- 1、公众号就是主题，业务就是推送新消息；
- 2、观察者订阅主题，有新的消息自动送来；
- 3、当不想要此主题消息时，取消订阅即可；
总结：
观察者模式的实现方式是在观察者调用主题的addObserver方法将自己添加到主题持有的观察者列表里，主题在需要的时候调用notifyObservers遍历观察者列表，并分别调用观察者的update方法。
打个比方，主题就是婚介所，多个观察者就是多个未婚大龄男青年，男青年注册会员之后将自己的联系方式交给婚介所，婚介所在合适的时候（比如来了适龄女青年），就会挨个给注册的男青年打电话通知。