观察者模式
- 观察者模式
- 观察者模式的特点
- 老板回来了
观察者模式
观察者模式又叫发布订阅模式。
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
Subject类，抽象的通知者，一般用一个接口或抽象类实现。它把所有的观察者对象的引用都保存起来，每个通知者可以有任意数量的观察者。抽象通知者通过了接口，可以增加和删除观察者对象。
Observer类，抽象观察者，为所有的具体观察者定义一个接口，在得到通知者的通知时更新自己。
ConcreteSubject 类，具体的通知者，内部引用了观察者，在特定情况下可以通知所有的观察者，更新观察者的状态。
ConcreteSubject 类，具体的观察者，实现抽象观察者角色所要求的更新接口，以便根据通知者的状态更新自己的状态。观察者可保存一个指向具体通知者对象的引用。
基本代码结构
通知者抽象类
abstract class Subject{
private ArrayList<Observer> list = new ArrayList<Observer>();//针对抽象的Observer编程
//增加观察者
public void attach(Observer observer){
list.add(observer);
}
//减少观察者
public void detach(Observer observer){
list.remove(observer);
}
//通知观察者
public void notifyObserver(){
for(Observer item : list){
item.update();
}
}
// 通知者的状态
protected String subjectState;
public String getSubjectState(){
return this.subjectState;
}
public void setSubjectState(String value){
this.subjectState = value;
}
}
具体通知者
class ConcreteSubject extends Subject{
//具体通知者的方法
}
抽象观察者
abstract class Observer{
// 定义了一个抽象更新方法，根据通知者，更新自身的状态
public abstract void update();
}
具体观察者类
class ConcreteObserver extends Observer{
private String name;
// 引用通知者，根据通知者的状态，进行更新
private Subject sub;
public ConcreteObserver(String name,Subject sub){
this.name = name;
this.sub = sub;
}
public void update(){
// 实现更新方法
System.out.println("观察者"+this.name+"的新状态是"+this.sub.getSubjectState());
}
}
客户端
public class Test {
public static void main(String[] args){
System.out.println("**********************************************");
System.out.println("《大话设计模式》代码样例");
System.out.println();
Subject subject = new ConcreteSubject();
subject.attach(new ConcreteObserver("NameX",subject));
subject.attach(new ConcreteObserver("NameY",subject));
subject.attach(new ConcreteObserver("NameZ",subject));
subject.setSubjectState("ABC");
subject.notifyObserver();
System.out.println();
System.out.println("**********************************************");
}
}
观察者模式的特点
将一个系统分割成一系列相互协作的类有一个不好的副作用，就是需要维护相关对象的一致性。不能为了维护一致性而使各类紧密耦合，这样会给维护，扩展和重用带来不便。
在观察者模式中，通知者和观察者进行了解耦。一个通知者可以被任意多个观察者依赖，一旦通知者的状态发生改变，就会通知所有观察者。而通知者发出通知的时候，并不需要具体的观察者是谁，依赖相同的通知者的观察者之间也是透明的。
什么时候使用观察者模式？
- 当一个对象改变需要同时改变其他对象的时候，而这个对象并不知道具体有多少个对象有待改变，应该考虑使用观察者模式。
- 当一个抽象模型有两个方面，其中一个方面依赖于另一个方面，这时用观察者模式可以将这两者封装在独立的对象使它们各自独立的改变和复用。
观察者模式所做的工作其实就是在解除耦合。让耦合的双方都依赖于抽象，而不是依赖于具体。从而使得各自的变化都不会影响另一边的变化。
老板回来了
老板不在，员工摸鱼，老板回来，通知员工工作。
在Java中，已经为观察者模式准备好了相关的接口和抽象类了。
观察者接口 java.util.Observer 和 通知者类 java.util.Observable
具体观察者（炒股的员工）
class StockObserver implements Observer{
protected String name;
public StockObserver(String name){
this.name = name;
}
public void update(Observable o, Object arg){
Subject b = (Subject)o;
System.out.println(b.name+"："+b.getAction()+"！"+this.name+"，请关闭股票行情，赶紧工作。");
}
}
具体的观察者（看NBA员工）
class NBAObserver implements Observer{
protected String name;
public NBAObserver(String name){
this.name = name;
}
public void update(Observable o, Object arg){
Subject b = (Subject)o;
System.out.println(b.name+"："+b.getAction()+"！"+this.name+"，请关闭NBA直播，赶紧工作。");
}
}
通知者类，继承扩展已有的类
class Subject extends Observable{
protected String name;
private String action;
public Subject(String name){
this.name = name;
}
//得到状态
public String getAction(){
return this.action;
}
//设置状态（就是设置具体通知的话）
public void setAction(String value){
this.action = value;
// 改变状态
setChanged();
// 通知所有观察者
notifyObservers();
}
}
具体的通知者（老板）
class Boss extends Subject{
public Boss(String name){
super(name);
}
}
客户端
public class Test {
public static void main(String[] args){
System.out.println("**********************************************");
System.out.println("《大话设计模式》代码样例");
System.out.println();
//老板胡汉三
Boss boss1 = new Boss("胡汉三");
//看股票的同事
Observer employee1 = new StockObserver("魏关姹");
Observer employee2 = new StockObserver("易管查");
Observer employee3 = new NBAObserver("兰秋幂");
//老板登记下三个同事
boss1.addObserver(employee1);
boss1.addObserver(employee2);
boss1.addObserver(employee3);
boss1.deleteObserver(employee1); //魏关姹其实没有被通知到，所有减去
//老板回来
boss1.setAction("我胡汉三回来了");
System.out.println();
System.out.println("**********************************************");
}
}
