1 public interface Observer {
 2     void update(Object arg);
 3 }
 4 
 5 public class ConcreteObserver implements Observer {
 6     @Override
 7     public void update(Object arg) {
 8         System.out.println("I accept arg: " + arg);
 9     }
10 }
11 
12 public abstract class Subject {
13     // 定义一个观察者数组(Vector线程安全)
14     private Vector<Observer> vector = new Vector<>();
15 
16     // 添加观察者
17     public synchronized void addObserver(Observer observer) {
18         vector.addElement(observer);
19     }
20 
21     // 删除一个观察者
22     public synchronized void removeObserver(Observer observer) {
23         vector.removeElement(observer);
24     }
25 
26     // 清空观察者
27     public synchronized void clear(Observer observer) {
28         vector.removeAllElements();
29     }
30 
31     // 通知观察者
32     public synchronized void notifyObservers(Object arg) {
33         for(Observer observer : vector) {
34             observer.update(arg);
35         }
36     }
37 }
38 
39 public class ConcreteSubject extends Subject {
40     // 定义自己的业务逻辑并通知观察者
41     public void operate() {
42         System.out.println("I do some operations and notify observes");
43         notifyObservers(null);
44     }
45 }
46 
47 public class Client {
48     public static void main(String[] args) {
49         // 创建观察者
50         Observer observer = new ConcreteObserver();
51         Observer observer1 = new ConcreteObserver();
52 
53         // 创建被观察者并添加观察者
54         ConcreteSubject subject = new ConcreteSubject();
55         subject.addObserver(observer);
56         subject.addObserver(observer1);
57 
58         // 被观察者活动并通知观察者
59         subject.operate();
60     }
61 }output:
62 I do some operations and notify observes
63 I accept arg: null
64 I accept arg: null

 1 public interface Observer {
 2     void update(Observable o, Object arg);
 3 }
 4 
 5 public class Observable {
 6     // 标识：标识被观察者是否改变
 7     private boolean changed = false;
 8     private Vector<Observer> obs;
 9 
10     public Observable() {
11         obs = new Vector<>();
12     }
13     // 添加观察者
14     public synchronized void addObserver(Observer o) {
15         if (o == null)
16             throw new NullPointerException();
17         if (!obs.contains(o)) {
18             obs.addElement(o);
19         }
20     }
21     // 删除观察者
22     public synchronized void deleteObserver(Observer o) {
23         obs.removeElement(o);
24     }
25     // 清空观察者
26     public synchronized void deleteObservers() {
27         obs.removeAllElements();
28     }
29     // 通知所有观察者
30     public void notifyObservers() {
31         notifyObservers(null);
32     }
33     public void notifyObservers(Object arg) {
34         /**
35          * 一个观察者缓冲区，用于并发访问被观察者时，留住观察者列表的当前状态，这样能够减少该对象加锁的时
36          * 间，这种处理方式其实也算是一种设计模式，即备忘录模式。
37          */
38         Object[] arrLocal;
39     /**
40      * 同步块：获得所有的观察者，以通知所有的观察者。这里使用同步块能够避免在通知中有人修改观察者
41      * 集合。如上所诉，使用观察者缓冲区能够减少该对象的加锁时间。
42      */
43         synchronized (this) {
44             if (!changed)
45                 return;
46             arrLocal = obs.toArray();
47             clearChanged();
48         }
49 
50         for (int i = arrLocal.length-1; i>=0; i--)
51             ((Observer)arrLocal[i]).update(this, arg);
52     }
53     // 设置该被观察者改变标识为true
54     protected synchronized void setChanged() {
55         changed = true;
56     }
57     // 设置该被观察者改变标识为false
58     protected synchronized void clearChanged() {
59         changed = false;
60     }
61 
62     public synchronized boolean hasChanged() {
63         return changed;
64     }
65     
66     public synchronized int countObservers() {
67         return obs.size();
68     }