标签：end 耦合 想去 重写 out 通知 main div notify
定义了一种一对多的依赖关系，让多个观察者对象去监听某一个主题对象，这个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。
//创建一个接口 定义被观察着的动作
public interface Subject {
/*增加观察者*/
public void add(Observer observer);
/*删除观察者*/
public void del(Observer observer);
/*通知所有的观察者*/
public void notifyObservers();
/*自身的操作*/
public void operation();
}
//定义一个观察者共同的动作接口
public interface Observer {
public abstract void update();
}
//创建第一个观察者实现上面接口
public class Observer1 implements Observer {
@Override
public void update() {
System.out.println("observer1 has received!");
}
}
//创建第二个观察者实现上面接口
public class Observer2 implements Observer {
@Override
public void update() {
System.out.println("observer2 has received!");
}
}
//创建抽象类实现上述被观察者的动作接口；重写里面的方法， 新增观察者、删除观察者、通知所有观察者
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();
}
}
通过main方法测试看看效果
public class MainTest {
public static void main(String[] args) {
Subject sub = new MySubject();
sub.add(new Observer1());
sub.add(new Observer2());
sub.operation();
}
}
//输出结果
update self!
observer1 has received!
observer2 has received!
接下来解读下上述代码：
观察者模式的关键对象时主题subject和观察者Observer，一个subject可以有任意数目的依赖他的Observer，一旦subject发生改变，所有的observer都能得到通知，subject发出通知时并不需要知道谁是他的观察者。而任何一个具体观察者也不需要知道其他观察者的存在。
当我们什么情况下使用观察者模式呢？
当一个对象的改变需要同时改变其他对象的时候。
总体来说观察者模式所做的工作就是接触耦合。让耦合的双方都依赖于抽象，而不是依赖于具体。从而使使各自的变化都不会影响另一边的变化。
到此lz探索的观察者模式就告一段落，相信通过上述代码读者们在心中也理解了一些观察者模式的内涵；
标签：end 耦合 想去 重写 out 通知 main div notify
原文地址：https://www.cnblogs.com/chenpt/p/9359041.html
