观察者模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主体对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
观察者模式结构图
什么时候使用观察者模式：当一个对象的改变需要同时改变其他对象的时候，而且它不知道具体有多少对象有待改变时，应该考虑使用观察者模式。
观察者模式所做的工作其实就是在解除耦合。让耦合的双方都依赖抽象，而不是依赖于具体。
全部自定义实现的观察者模式
package com.observer;
//被观察对象的接口
public interface Subject {
//add observer
public void add(Observer o);
public void del(Observer o);
//通知所有观察者
public void notifyObservers();
//被观察对象的一些操作
public void operation();
}
package com.observer;
import java.util.Iterator;
import java.util.Vector;
public class AbstractSubject implements Subject {
private Vector<Observer> vector = new Vector<Observer>();
@Override
public void add(Observer o) {
vector.add(o);
}
@Override
public void del(Observer o) {
vector.remove(o);
}
@Override
public void notifyObservers() {
Iterator i = vector.iterator();
while(i.hasNext()){
Observer o = (Observer)i.next();
o.update();
}
}
@Override
public void operation() {
}
}
package com.observer;
public class MySubject extends AbstractSubject {
@Override
public void operation() {
super.operation();
System.out.println("被观察者变化：");
this.notifyObservers();
}
}
package com.observer;
//观察者接口
public interface Observer {
public void update();
}
package com.observer;
public class Observer1 implements Observer {
@Override
public void update() {
System.out.println("observer1 update");
}
}
package com.observer;
public class Observer2 implements Observer {
@Override
public void update() {
System.out.println("observer2 update");
}
}
package com.observer;
/**
* ClassName: Main
* @Description:观察者模式（Observer）：
* 当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。
* MySubject类就是我们的主对象，Observer1和Observer2是依赖于MySubject的对象，
* 当MySubject变化时，Observer1和Observer2必然变化。AbstractSubject类中定义着需要监控的对象列表，
* 可以对其进行修改：增加或删除被监控对象，且当MySubject变化时，负责通知在列表内存在的对象。
* @author Panyk
* @date 2015年10月14日
*/
public class Main {
public static void main(String[] args) {
Subject s = new MySubject();
s.add(new Observer1());
s.add(new Observer2());
s.operation();
}
}
利用jdk实现的观察者模式
package com.observer;
import java.util.Observable;
import java.util.Observer;
/**
* ClassName: Reception
* @Description: 前台妹子类
* @author Panyk
* @date 2016年3月23日
*/
public class Reception extends Observable {
String action = "";
@Override
public synchronized void addObserver(Observer o) {
super.addObserver(o);
}
@Override
public synchronized void deleteObserver(Observer o) {
super.deleteObserver(o);
}
@Override
public void notifyObservers() {
super.notifyObservers();
}
@Override
public String toString() {
return "Reception [action=" + action + "]";
}
public String getAction() {
return action;
}
public void setAction(String action) {
this.setChanged();//必须先setChanged，否则notifyObservers不起作用。
this.action = action;
this.notifyObservers(1);//这里的参数会传递给观察者
System.out.println("notifyObservers之后，自动置为了false，再次notifyObservers不起作用。" + this.hasChanged());
this.notifyObservers();
}
}
package com.observer;
import java.util.Observable;
import java.util.Observer;
public class Programer implements Observer {
String name = "";
public Programer(String name) {
this.name = name;
}
@Override
public void update(Observable o, Object arg) {//o是被观察者对象，arg是被观察者传递过来的变量
System.out.println("--------------");
System.out.println(name);
System.out.println(o);
System.out.println(arg);
}
}
package com.observer;
import java.util.Observable;
import java.util.Observer;
public class Main {
public static void main(String[] args) {
Observer p1 = new Programer("zhangsan1");
Observer p2 = new Programer("zhangsan2");
Observer p3 = new Programer("zhangsan3");
Observer p4 = new Programer("zhangsan4");
Observer p5 = new Programer("zhangsan5");
Reception r = new Reception();
r.addObserver(p1);
r.addObserver(p2);
r.addObserver(p3);
r.addObserver(p4);
r.addObserver(p5);
r.setAction("哈哈");
}
}
//输出结果
--------------
zhangsan5
Reception [action=哈哈]
1
--------------
zhangsan4
Reception [action=哈哈]
1
--------------
zhangsan3
Reception [action=哈哈]
1
--------------
zhangsan2
Reception [action=哈哈]
1
--------------
zhangsan1
Reception [action=哈哈]
1
notifyObservers之后，自动置为了false，再次notifyObservers不起作用。false
