责任链模式和观察者模式

责任链模式

避免请求发送者与接收者耦合在一起，让多个对象都有可能接受请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

通过下面例子，当办公室失火，会通知仓库的保安，保安会通知整个大楼。

抽象区域：

   public abstract class Zone{
	   private Zone parentName;
	   private String localName;
	   
	   public Zone(String name) {
		   localName = name;
	   }

		public void setParentName(Zone parentName) {
			this.parentName = parentName;
		}
	   
	
		public void notifyPare() {
			if(parentName != null) {
				parentName.notifyPare();
				return;
			}
			
			dosomething();
		}
		
		abstract void dosomething();
	   
   }

具体实现类：

  /**
    * 办公室
    * @author jiahua
    *
    */
   
   public class Office extends Zone {

	public Office(String name) {
		super(name);
	}

	@Override
	void dosomething() {
		System.out.println("打开喷洒器喷水");
		
	}
	   
   }
   
   /**
    * 仓库
    * @author jiahua
    *
    */
   public class Warehouse extends Zone {

	public Warehouse(String name) {
		super(name);
	}

	@Override
	void dosomething() {
		System.out.println("呼叫保安");
		
	}
	   
   }
   
   /**
    * 大楼
    * @author jiahua
    *
    */
   
   public class Building extends Zone {

	public Building(String name) {
		super(name);
	}

	@Override
	void dosomething() {
		System.out.println("大楼警报");
		
	}
	   
   }

主类：

   public static void main(String args[]){
	   Office office = new Office("办公室");
	   Warehouse warehouse = new Warehouse("仓库");
	   office.setParentName(warehouse);
	   Building building = new Building("大楼");
	   warehouse.setParentName(building);
	   
	  office.notifyPare();
   }

责任链模式可以减少对象的链接，为对象责任分配增加了灵活性。该模式允许一组类作为一个类来使用，并且在类的组合中，一个类的事件可以发送到另一个类并由其处理。

观察者模式

定义对象间的一种一对多依赖关系，使得每当一个对象改变状态，则其相关依赖对象皆得到通知并被自动更新。

/**
 * 观察者接口
 * @author jiahua
 *
 */
interface IListenner {
	public void dosomething();
}

/**
 * 通知观察者
 * @author jiahua
 *
 */
class publisher {
	List<IListenner> list = new ArrayList<>();
	
	public void addListener(IListenner listenner) {
		list.add(listenner);
	}
	
	public void notifyAllListener() {
		for (IListenner iListenner : list) {
			iListenner.dosomething();
		}
	}
}

/**
 * 观察者的实现
 * @author jiahua
 *
 */
class listenerOne implements IListenner{

	@Override
	public void dosomething() {
		System.out.println("listenerOne  获得消息");
	}
}

class listenerTwo implements IListenner{

	@Override
	public void dosomething() {
		System.out.println("listenerTwo  获得消息");
	}
}

class listenerThree implements IListenner{

	@Override
	public void dosomething() {
		System.out.println("listenerThree   获得消息");
	}

   public static void main(String args[]){
	   publisher publisher = new publisher();
	   
	   publisher.addListener(new listenerOne());
	   publisher.addListener(new listenerTwo());
	   publisher.addListener(new listenerThree());
	   
	   publisher.notifyAllListener();
   }

观察者模式抽象了被观察者与观察者对象的连接，提供了广播式的对象间通信，并且容易增加新的观察者对象。