这里记录一下观察者模式,偶尔会用到,也比较好理解。
观察者模式:定义了一种一对多的依赖关系,让多个观察者对象同时监听一个主题对象,在主题对象改变时会同时通知所有注册的观察者对象,使它们能够自动更新自己。
采用原书场景:办公室员工为观察者,所有人都约定(订阅)了前台小姐姐,如果老板回来就通知他们,他们收起小差继续工作。
你会怎么写代码,是就前台类,员工类吗?
原书UML如下:
这里对员工和通知者(前台,或者老板【走后门进来前台不知道】)进行了抽象,不然在员工类里会依赖具体的通知者类,通知者类里也会依赖具体的员工类,这样通知者类更换了,员工类也必须修改对象类型,就耦合了,不利于拓展和维护。
测试类如下:
package com.gcc.ObserverModel;
/**
* 观察者模式:定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。
* 在这个主题地下变化时,会通知所有观察着对象,使它们自动更新某个动作。
*
* 本例解释:生成一个通知者,这个人可以是前台可以是老板等等。 new ReceptionNotify()
* 生成希望接到通知的观察者,同时赋予姓名和希望得到哪个通知者.new ObserverA("张三",renotify)
* 通知者添加他愿意通知的人.renotify.addObserver(oa)
* 通知者设置通知的内容状态.renotify.setState("前台状态:老板回来了");
* 通知者发送通知.renotify.notifyAction();
*/
public class TestObserver {
public static void main(String[] args) {
ReceptionNotify renotify = new ReceptionNotify();
ObserverA oa = new ObserverA("张三",renotify);
ObserverB ob = new ObserverB("李四",renotify);
ObserverC oc = new ObserverC("王五",renotify);
renotify.addObserver(oa);
renotify.addObserver(ob);
renotify.addObserver(oc);
renotify.removeObserver(ob);//取消订阅通知
renotify.setState("前台状态:老板回来了");
renotify.notifyState();
renotify.notifyAction();
System.out.println();
//----------------------------------------
BossNotify bossNotify = new BossNotify();
ObserverA oa2 = new ObserverA("张三",bossNotify);
ObserverB ob2 = new ObserverB("李四",bossNotify);
ObserverC oc2 = new ObserverC("王五",bossNotify);
bossNotify.addObserver(oa2);
bossNotify.addObserver(ob2);
bossNotify.addObserver(oc2);
bossNotify.setState("老板状态:本老板回来了");
bossNotify.notifyState();
bossNotify.notifyAction();
}
}
员工(观察者)接口:
package com.gcc.ObserverModel;
public interface Observer {
void update();
}
员工类:
package com.gcc.ObserverModel;
public class ObserverA implements Observer {
String name;
Notify notify;
public ObserverA() {
super();
}
public ObserverA(String name,Notify notify) {
super();
this.name = name;
this.notify = notify;
}
public void askNotifyState(){
this.notify.notifyState();
}
@Override
public void update() {
System.out.println(this.name+"关闭NBA直播,继续工作");
}
}
package com.gcc.ObserverModel;
public class ObserverB implements Observer {
String name;
Notify notify;
public ObserverB() {
super();
}
public ObserverB(String name,Notify notify) {
super();
this.name = name;
this.notify = notify;
}
@Override
public void update() {
System.out.println(this.name+"关闭股票行情,继续工作");
}
}
package com.gcc.ObserverModel;
public class ObserverC implements Observer {
String name;
Notify notify;
public ObserverC() {
super();
}
public ObserverC(String name,Notify notify) {
super();
this.name = name;
this.notify = notify;
}
@Override
public void update() {
System.out.println(this.name+"关闭新番动漫,继续工作");
}
}
通知(主题)接口:
package com.gcc.ObserverModel;
public interface Notify {
void addObserver(Observer observer);
void removeObserver(Observer observer);
void notifyAction();
void notifyState();
}
通知类:
package com.gcc.ObserverModel;
import java.util.ArrayList;
import java.util.List;
public class ReceptionNotify implements Notify {
private String state;
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
List<Observer> list = new ArrayList<Observer>();
@Override
public void addObserver(Observer observer) {
list.add(observer);
}
@Override
public void removeObserver(Observer observer) {
list.remove(observer);
}
@Override
public void notifyAction() {
for (Observer o : list) {
o.update();
}
}
@Override
public void notifyState() {
System.out.println(this.state);
}
}
package com.gcc.ObserverModel;
import java.util.ArrayList;
import java.util.List;
public class BossNotify implements Notify {
private String state;
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
List<Observer> list = new ArrayList<Observer>();
@Override
public void addObserver(Observer observer) {
list.add(observer);
}
@Override
public void removeObserver(Observer observer) {
list.remove(observer);
}
@Override
public void notifyAction() {
for (Observer o : list) {
o.update();
}
}
@Override
public void notifyState() {
System.out.println(this.state);
}
}
运行结果如下:
前台状态:老板回来了
张三关闭NBA直播,继续工作
王五关闭新番动漫,继续工作
老板状态:本老板回来了
张三关闭NBA直播,继续工作
李四关闭股票行情,继续工作
王五关闭新番动漫,继续工作
简单来理解,观察者模式就是解除耦合,让耦合的双方都依赖于抽象(接口),而不依赖于具体,从而使得各自的变化不会影响另一方。
感谢观看,咧。