23种创新模式总署
父文链接

理解：很好理解，假设有a和b，b看到a改变的，因此b也改变了。
这里a是被观察,b是观察者。。。

当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化,对象之间是一种一对多的关系.

实现思路：

a持有b，当a改变时，调用b的方法。。。oc的代理回传～

代码

public interface Observer {  
    public void update();  //观察者接口
}
public class Observer1 implements Observer {  //观察者1
  
    @Override  
    public void update() {  
        System.out.println("observer1 has received!");  
    }  
}
public class Observer2 implements Observer {  //观察者2
  
    @Override  
    public void update() {  
        System.out.println("observer2 has received!");  
    }  
  
}

被观察者

public interface Subject {  
      
    /*增加观察者*/  
    public void add(Observer observer);  
      
    /*删除观察者*/  
    public void del(Observer observer);  
      
    /*通知所有的观察者*/  
    public void notifyObservers();  
      
    /*自身的操作*/  
    public void operation();  
}
//抽象类，子类只需要实现operation()就可以了
public abstract class AbstractSubject implements Subject {  
  
    private Vector<Observer> vector = new Vector<Observer>();  
    @Override  
    public void add(Observer observer) {  
        vector.add(observer);  
    }  
  
    @Override  
    public void del(Observer observer) {  
        vector.remove(observer);  
    }  
  
    @Override  
    public void notifyObservers() {  
        Enumeration<Observer> enumo = vector.elements();  
        while(enumo.hasMoreElements()){  
            enumo.nextElement().update();  
        }  
    }  
}
//被观察者
public class MySubject extends AbstractSubject {  
  
    @Override  
    public void operation() {  
        System.out.println("update self!");  
        notifyObservers();  
    }  
  
}

使用

public class ObserverTest {  
  
    public static void main(String[] args) {  
        Subject sub = new MySubject();  
        sub.add(new Observer1());  
        sub.add(new Observer2());  
          
        sub.operation();  //被观察者通知观察者们，做出响应
    }  
  
}