观察者模式定义：
一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。
什么时候可以使用观察者模式？
- 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
- 当对一个对象的改变需要同时改变其它对象，而不知道具体有多少对象有待改变。
- 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之你不希望这些对象是紧密耦合的。
有两种方式可以实现观察者模式代码
1、通过jdk自带的观察者模式相关的类进行扩展
jdk自带了发布者抽象类Observable和订阅者接口Observer，以下代码中的发布者类继承了Observable，订阅者实现了Observer接口，重写了其中的update方法。
/**
* 发布者
*/
public class Promulgator extends Observable{
private int data = 0;
public int getData() {
return data;
}
public void setData(int data) {
if(this.data != data){
this.data = data;
//这里要将发布者的是否改变字段设置为true,否则不能通知订阅者
this.setChanged();
}
}
}
/**
* 订阅者A
*/
public class SubscriberA implements Observer{
@Override
public void update(Observable paramObservable, Object paramObject) {
System.out.println("这里是订阅者A-------------");
System.out.println("获得的data的值是："+paramObject.toString());
}
}
/**
* 订阅者B
*/
public class SubscriberB implements Observer{
@Override
public void update(Observable paramObservable, Object paramObject) {
System.out.println("这里是订阅者B-------------");
System.out.println("获得的data的值是："+paramObject.toString());
}
}
/**
* 测试类
*/
public class ObserverTest {
public static void main(String[] args) {
//创建发布者
Promulgator promulgator = new Promulgator();
//创建两个订阅者
SubscriberA subscribera = new SubscriberA();
SubscriberB subscriberb = new SubscriberB();
//将两个订阅者注册到发布者对象中
promulgator.addObserver(subscribera);
promulgator.addObserver(subscriberb);
//将发布者中的data值设为2
promulgator.setData(2);
System.out.println(promulgator.hasChanged() );
promulgator.notifyObservers(promulgator.getData());
//开始测试设置相同的值会不会继续通知订阅者
System.out.println("--------开始");
promulgator.setData(2);
promulgator.notifyObservers(promulgator.getData());
System.out.println("--------结束");
}
}2、自己实现观察者模式相关类
如果不想用jdk自带的观察者类，可以自己去实现，定义观察者和被观察者接口并且各自实现子类。
/**
* 观察者接口，定义update方法，用于被通知
*/
public interface Observer {
//更新方法，被观察者在数据更新后会通过这个方法通知观察者
public void update(Object paramObject);
}
/**
* 被观察者
*/
public interface Observerable {
//注册观察者
public void registerObserver(Observer o);
//移除观察者
public void removeObserver(Observer o);
//通知观察者
public void notifyAllObserver();
}
/**
* 观察者A实现Observer接口，并且实现update方法
*/
public class SelfObserverA implements Observer {
@Override
public void update(Object paramObject) {
System.out.println("我是观察者A,我得到的data的值是："+paramObject.toString());
}
}
/**
* 观察者B
*/
public class SelfObserverB implements Observer {
@Override
public void update(Object paramObject) {
System.out.println("我是观察者B,我得到的data的值是："+paramObject.toString());
}
}
//被观察者，实现被观察者接口中所有方法
public class SelfObserverable implements Observerable{
//用于标识内容是否已更新
private boolean changed = false;
private int data = 0;
private List<Observer> observerList = new ArrayList<>();
@Override
public void registerObserver(Observer o) {
observerList.add(o);
}
@Override
public void removeObserver(Observer o) {
observerList.remove(o);
}
@Override
public void notifyAllObserver() {
if(!this.changed){
return;
}
Iterator<Observer> iterator = observerList.iterator();
while(iterator.hasNext()){
iterator.next().update(this.data);
}
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public boolean isChanged() {
return changed;
}
public void setChanged(boolean changed) {
this.changed = changed;
}
}
//测试类
public class ObserverTest {
public static void main(String[] args) {
//创建被观察者
SelfObserverable observerable = new SelfObserverable();
//创建观察者A
Observer observerA = new SelfObserverA();
//创建观察者B
Observer observerB = new SelfObserverB();
//将观察者A和观察者B注册到被观察者对象中
observerable.registerObserver(observerA);
observerable.registerObserver(observerB);
//给data设置
observerable.setData(10);
//设置更新状态
observerable.setChanged(true);
//通知所有观察者
observerable.notifyAllObserver();
}
}