简单理解常用设计模式（十）观察者模式

这里记录一下观察者模式，偶尔会用到，也比较好理解。

观察者模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听一个主题对象，在主题对象改变时会同时通知所有注册的观察者对象，使它们能够自动更新自己。

采用原书场景：办公室员工为观察者，所有人都约定（订阅）了前台小姐姐，如果老板回来就通知他们，他们收起小差继续工作。

你会怎么写代码，是就前台类，员工类吗？

原书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直播，继续工作

李四关闭股票行情，继续工作

王五关闭新番动漫，继续工作

简单来理解，观察者模式就是解除耦合，让耦合的双方都依赖于抽象（接口），而不依赖于具体，从而使得各自的变化不会影响另一方。

感谢观看，咧。