//一个Observer接口：
1.public interface Observer {  
2.    public void update();  
3.}  

//两个实现类：
1.public class Observer1 implements Observer {  
2.  
3.    @Override  
4.    public void update() {  
5.        System.out.println("observer1 has received!");  
6.    }  
7.}  
1.public class Observer2 implements Observer {  
2.  
3.    @Override  
4.    public void update() {  
5.        System.out.println("observer2 has received!");  
6.    }  
7.  
8.}  

//订阅者接口
public interface Subject {  
2.      
3.    /*增加观察者*/  
4.    public void add(Observer observer);  
5.      
6.    /*删除观察者*/  
7.    public void del(Observer observer);  
8.      
9.    /*通知所有的观察者*/  
10.    public void notifyObservers();  
11.      
12.    /*自身的操作*/  
13.    public void operation();  
14.}  
//实现接口的抽象类
1.public abstract class AbstractSubject implements Subject {  
2.  
3.    private Vector<Observer> vector = new Vector<Observer>();  
4.    @Override  
5.    public void add(Observer observer) {  
6.        vector.add(observer);  
7.    }  
8.  
9.    @Override  
10.    public void del(Observer observer) {  
11.        vector.remove(observer);  
12.    }  
13.  
14.    @Override  
15.    public void notifyObservers() {  
16.        Enumeration<Observer> enumo = vector.elements();//放入观察者的集合，并循环遍历来调用（通知）观察者的update（）方法
17.        while(enumo.hasMoreElements()){  
18.            enumo.nextElement().update();  
19.        }  
20.    }  
21.}  
//继承抽象类的具体实现类
1.public class MySubject extends AbstractSubject {  
2.  
3.    @Override  
4.    public void operation() {  
5.        System.out.println("update self!");  
6.        notifyObservers();  
7.    }  
8.  
9.}  

//将所有 的观察者放入集合并调用订阅函数
public class ObserverTest {  
2.  
3.    public static void main(String[] args) {  
4.        Subject sub = new MySubject();  
5.        sub.add(new Observer1());  
6.        sub.add(new Observer2());  
7.          
8.        sub.operation();  
9.    }  
10.  
11.}