大话设计模式--观察者模式

    一个情景中，前台给指定员工发送信息，提醒老总回来了，要员工及时关闭无关事情，开始工作。提醒他们老总来了不要玩了。具体代码如下：

这是前台发送者的类

package effective.Observer;

import java.util.ArrayList;
import java.util.List;

public class Secretary {
	//同事列表
	private List<StockObserver> observers = new ArrayList<StockObserver>();
	private String action;
	//增加
	public void Attch(StockObserver observer){
		observers.add(observer);
	}
	//通知
	public void Notify(){
		for (StockObserver so : observers) {
			so.update();
		}
	}
	//删除通知者
	public void delPerson(StockObserver sb){
		observers.remove(sb);
	}
	// 前台状态
	public void setAction(String action){
		this.action = action;
	}
	public String getAction(){
		return action;
	}
}

这是接受者（同事）

public 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+",关闭股票行情，继续工作");
		
	}}

客户端的代码：

//前台ly
		Secretary ly = new Secretary();
		//看股票的同事
		StockObserver ts1 = new StockObserver("陈某某", ly);
		StockObserver ts2 = new StockObserver("郑某某", ly);
		
		//前台记下了两位同事
		ly.Attch(ts1);
		ly.Attch(ts2);
		ly.delPerson(ts2);
		//发现老板回来
		ly.setAction("老板回来了");
		//通知同事
		ly.Notify();

输出：

老板回来了,陈某某,关闭股票行情，继续工作

从以上代码可知，发送者（前台过于耦合），比如我要发送者是老总，那么就要再写一个老总的类，代码类似。即出现重复代码，或者我要发送者添加新的方法，即要改动原来的代码。这就显得代码不够灵活。

 解决的办法是，讲发送者的方法抽象出来，发送者继承该抽象类，无论发送者是前台，还是老总。。都能实现想要的功能，并且代码客服有性高，若 老总还需要添加其他方法（如加工资）也可以相应增加，改动量就很小。

    具体代码如下：

发送

package effective.Observer2;
/**
 * 发送者的抽象
 * @author 李宇
 *
 */
public abstract class SendMsg {
	protected String position;//职位
	protected String action;//发送者要做出的行动
	protected String msg;
	public SendMsg(String posi,String action){
		this.position = posi;
		this.action = action;
	}
	abstract void sendMsg(String msg);//发送信息
	abstract void addPerson(Person person);//添加发送的人
	abstract void delPerson(Person person);//删除发送的人 
	abstract void setAction(String action);//发送者要做出的行动
	
}

接受者的抽象类：

package effective.Observer2;
/**
 * 接受者的抽象类
 * @author 李宇
 *
 */
public abstract class Observer {
	protected String name ;
	protected SendMsg send;
	protected String action;
	public Observer(String name , SendMsg send){
		this.name = name;
		this.send = send;
	}
	public   abstract void  action();//观察者要做出的行动
	
}

发送者的类：

package effective.Observer2;

import java.util.ArrayList;
import java.util.List;

public class Boss extends SendMsg {

	public Boss(String posi, String action) {
		super(posi, action);
	}

	List<Person> list = new ArrayList<Person>();
	
	@Override
	public void sendMsg(String msg) {
		// TODO Auto-generated method stub
		super.msg = msg;
	}

	@Override
	public void addPerson(Person person) {
		// TODO Auto-generated method stub
		list.add(person);
	}


	@Override
	void delPerson(Person person) {
		// TODO Auto-generated method stub
		list.remove(person);
	}

	@Override
	void setAction(String action) {
		// TODO Auto-generated method stub
		super.action = action;
	}

}

接受者的类：

public class Person extends Observer{
	public Person(String name, SendMsg send) {
		super(name, send);
		// TODO Auto-generated constructor stub
	}
	@Override
	public void action() {
		// TODO Auto-generated method stub
		System.out.println(super.send.position+"  "+super.send.action+" "+super.send.msg+"  "+super.name+"关闭NBA,赶紧工作");
	}
}

客户端：

Boss boss1 = new Boss("老板","回来了");
	boss1.sendMsg(" 准备开会 ！！");
	Person pes1 = new Person("小李",boss1);
	Person pes2 = new Person("小张",boss1);
	boss1.addPerson(pes1);
	boss1.addPerson(pes2);
	pes1.action();
	pes2.action();

输出：

老板  回来了  准备开会 ！！  小李关闭NBA,赶紧工作
老板  回来了  准备开会 ！！  小张关闭NBA,赶紧工作

所以观察者模式，适用于 一个对象改名，同事改变其他对象的时候