设计模式(Java)----观察者模式Observer

问题引入：办公时间做与工作无关的事情，在老板到来时，前台负责通知好友进入工作状态.

import java.util.ArrayList;
class Secretary{//前台秘书类
	private ArrayList<StockObserver>observers=new ArrayList<StockObserver>();
	private String action;
	public void Attach(StockObserver observer) {
		observers.add(observer);
	}
	public void Notify() {
		for(int i=0;i<observers.size();i++) {
			observers.get(i).Update();
		}
	}
	public String getAction() {
		return action;
	}
	public void setAction(String action) {
		this.action=action;
	}
}
class StockObserver{//看股票同事类
	private String name;
	private Secretary sub;
	public StockObserver(String name,Secretary sub) {
		this.name=name;
		this.sub=sub;
	}
	public void Update() {//得到前台通知
		System.out.println(sub.getAction()+name+"关闭股票行情，继续工作！");
	}
}

public  class Main{
	public static void main(String[] args){
	Secretary tongzhizhe=new Secretary();
	StockObserver tongshi1=new StockObserver("小王",tongzhizhe);
	StockObserver tongshi2=new StockObserver("小李",tongzhizhe);
	tongzhizhe.Attach(tongshi1);
	tongzhizhe.Attach(tongshi2);
	tongzhizhe.setAction("老板回来了");
	tongzhizhe.Notify();
	
	}
}

问题：前台类要增加观察者，观察者类需要前台的状态， 前台类和为股票者类之间互相耦合。如见观察者中还有人想看NBA直播，前台类代码就需要更改。因为前台类和StockObserver都是具体类，依赖具体使得类与类之间产生了紧密联系(耦合),以后假如出现变化，则变一次就要改一次，违背了开放-封闭原则。
解决办法：依赖倒转原则--依赖于抽象，而不是相互依赖，依赖抽象才能应对变化，避免耦合。

import java.util.ArrayList;
abstract class Subject{//抽象通知者
	abstract void Attach(Observer observer);//添加观察者
	abstract void Detach(Observer observer);//删除观察者
	abstract void Notify();//通知观察者
	String action;
	public String getAction() {//老板状态
		return action;
	}
	public void setAction(String action) {
		this.action=action;
	}
}
class Boss extends Subject{//同事列表
	private ArrayList<Observer>observers=new ArrayList<Observer>();

@Override
void Attach(Observer observer) {
	// TODO Auto-generated method stub
	observers.add(observer);
}

@Override
void Detach(Observer observer) {
	// TODO Auto-generated method stub
	observers.remove(observer);
}

@Override
void Notify() {
	// TODO Auto-generated method stub
	for(int i=0;i<observers.size();i++) {
		observers.get(i).Update();
	}
}
	
}
class Secretary extends Subject{//同事列表
	private ArrayList<Observer>observers=new ArrayList<Observer>();

@Override
void Attach(Observer observer) {
	// TODO Auto-generated method stub
	observers.add(observer);
}

@Override
void Detach(Observer observer) {
	// TODO Auto-generated method stub
	observers.remove(observer);
}

@Override
void Notify() {
	// TODO Auto-generated method stub
	for(int i=0;i<observers.size();i++) {
		observers.get(i).Update();
	}
}
	
}
abstract class Observer{
	protected String name;
	protected Subject sub;
	public Observer(String name,Subject sub) {
		this.name=name;
		this.sub=sub;
	}
	public abstract void Update();
}
class StockObserver extends Observer{
	public StockObserver(String name,Subject sub) {
		super(name,sub);
	}

	@Override
	public void Update() {
		// TODO Auto-generated method stub
		System.out.println(sub.getAction()+name+"关闭股票行情，继续工作！");
	}

}
class NBAObserver extends Observer{
	public NBAObserver(String name,Subject sub) {
		super(name,sub);
	}

	@Override
	public void Update() {
		// TODO Auto-generated method stub
		System.out.println(sub.getAction()+name+"关闭NBA直播，继续工作！");
	}

}
public  class Main{
	public static void main(String[] args){
		Secretary tongzhizhe=new Secretary();
		StockObserver tongzhizhe1=new StockObserver("小李",tongzhizhe);
		NBAObserver tongzhizhe2=new NBAObserver("小张",tongzhizhe);
		tongzhizhe.Attach(tongzhizhe1);
		tongzhizhe.Attach(tongzhizhe2);
		tongzhizhe.setAction("老板回来了");
		tongzhizhe.Notify();
	}
}

结果为：
老板回来了小李关闭股票行情，继续工作！
老板回来了小张关闭NBA直播，继续工作！

观察者模式

Subject类：主题或抽象通知者，一个目标可以被多个观察者观察，目标提供对观察者注册和退订的维护，当目标的状态发生变化时， 目标负责通知所有注册的、有效的观察者。
抽象观察者(Observer)角色:为所有的具体观察者定义一个接口， 在得到主题的通知时更新自己。这个接口叫做更新接口。
具体观察者(ConcreteObserver)角色:具体现察者角色，实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体现察者角色可以保存一个指向具体主题对象的引用。

import java.util.ArrayList;

abstract class Subject{
	private ArrayList<Observer>observers=new ArrayList<Observer>();
	public void attach(Observer observer) {
		observers.add(observer);
	}
	public void detach(Observer onserver) {
		observers.remove(observer);
	}
	void Notify() {
		for(int i=0;i<observers.size();i++) {
			observers.get(i).update();
		}
	}
}
abstract class Observer{
	public abstract void update();
}
class ConcreteSubject extends Subject{
	private String subjectState;

	public String getSubjectState() {
		return subjectState;
	}

	public void setSubjectState(String subjectState) {
		this.subjectState = subjectState;
	}
	
}
class ConcreteObserver extends Observer{

	private String name;
	private String observerState;
	private ConcreteSubject subject;
	public ConcreteObserver(ConcreteSubject subject,String name) {
		this.name=name;
		this.subject=subject;
	}
	@Override
	public void update() {
		// TODO Auto-generated method stub
		observerState=subject.getSubjectState();
		System.out.println("观察者"+name+"的新状态是"+observerState);
	}
	
}
public  class Main{
	public static void main(String[] args){
		ConcreteSubject s=new ConcreteSubject();
		s.attach(new ConcreteObserver(s,"X"));
		s.attach(new ConcreteObserver(s,"Y"));
		s.attach(new ConcreteObserver(s,"Z"));
		s.setSubjectState("ABC");
		s.Notify();
	}
}

 结果为：
观察者X的新状态是ABC
观察者Y的新状态是ABC
观察者Z的新状态是ABC

什么时候使用观察者模式?
1、当一个对象的改变需要同时改变其他对象，而且它不知道具体有多少对象有待改变时，应该考虑使用观察者模式。
2、当一个抽象模式有两个方面，其中一方面依赖于另一方面，这时用观察者模式可以将两者封装在独立的对象中使它们各自独立地改变和复用。

3、观察者模式所做的工作就是解除耦合。让耦合的双方都依赖于抽象，而不是依赖于具体。从而使得各自的变化都不会影响另一边的变化。
这是依赖倒转原则的最佳体现。
单向依赖
观察者和目标是单向依赖的，只有观察者依赖于目标，而目标不依赖于观察者。
通知顺序
目标对象的状态变化后通知所有观察者的时候，顺序是不确定的，因此观察者实现的功能，不要依赖于通知顺序，也就是说，多个观察者之间的功能是平行的，相互不应该有先后顺序。
优点：
1、观察者模式实现了观察者和目标之间的抽象耦合。
2、观察者模式实现了动态联动。
3、观察者模式支持广播通信。被观察者会向所有的登记过的观察者发出通知。
不足：
1、尽管已经用了依赖倒转原则，但是‘抽象通知者’还是依赖‘抽象观察者’，也就是说，万一没有了抽象观察者这样的接口，通知的功能就完成不了。
2、被观察者会向所有的登记过的观察者发出通知，不管观察者需不需要，每个观察者都会被调用update方法。

Java中的观察者模式
例题：观察者为羊，被观察者为狼。模仿的场景为狼叫羊跑。

import java.util.Observable;
import java.util.Observer;

class Wolf extends Observable{
	private String name;
	Wolf(String name){
		this.name=name;
	}
	public void shout(String state) {
		System.out.println(this.getName()+"shouting");
		this.setChanged();
		this.notifyObservers(state);
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}
class Sheep implements Observer{
	private String state="eating";
	private String name;
	public Sheep(String name) {
		this.name=name;
	}
	public void update(Observable o,Object arg) {
		Wolf wolf=(Wolf)o;
		System.out.println(wolf.getName()+"shouting and"+arg+""+this.getName()+"running");
		setState("runing");
	}
	public String getState() {
		return state;
	}
	public void setState(String state) {
		this.state = state;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}
public  class Main{
	public static void main(String[] args){
		Wolf wolf=new Wolf("wolf1");
		Sheep sheep1=new Sheep("sheep1");
		Sheep sheep2=new Sheep("sheep2");
		Sheep sheep3=new Sheep("sheep3");
		wolf.addObserver(sheep1);
		wolf.addObserver(sheep2);
		String wolfstat="hungry";
		wolf.shout(wolfstat);
	}
}

结果为：
wolf1shouting
wolf1shouting andhungrysheep2running
wolf1shouting andhungrysheep1running