黑马程序员技术交流社区

标题: 观察者设计模式 [打印本页]
作者: Tking    时间: 2014-4-9 08:09
标题: 观察者设计模式
观察者设计模式
定义：定义对象间一对多的依赖关系，使得当每个对象改变状态，则所依赖于他的对象都会得到通知并自动更新。
观察者模式的结构：
在最基础的观察者模式中，包括四个角色。
抽象主题(Observable)角色：抽象主题角色把所有对观察者对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，抽象主题角色又叫做抽象被观察者角色。
具体主题(？ Extends Observable)角色：将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者角色。
抽象观察者(Observer)角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己，这个接口叫做更新接口。
具体观察者(? Implements Observer)角色：存储与主题的状态自恰的状态。具体观察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态 像协调。如果需要，具体观察者角色可以保持一个指向具体主题对象的引用。
用通俗的方式来举例说明观察者模式的好处。
故事情节：三国时期的赤壁大战，曹操听说诸葛亮会呼风唤雨，就派遣三名侦察兵去窥视诸葛军师的一举一动，并且在第一时间汇报出来。（第一时间，当然是要在诸葛军师还没有施法之前得到这个讯息）
分析：被观察者：诸葛孔明==>军师
      观察者：侦察兵==>小兵
只要先描述出军师这个类，与小兵这个类，并让他们扯上点什么关系就行，这里JDk里有两个类Observer and Observable分别完成了观察主题与被观察主题的基本功能，只需要继承，和实现便可以完成。
先描述军师类：
  1. import java.util.Observable;
  2. //描述一个军师类
  3. public class jushi extends Observable
  4. {
  5.          private String name;//军师的姓名
  6.          private String args;//军师的状态
  7.          jushi(String name)
  8.          {
  9.                  this.name=name;
  10.          }
  11.          public String toString()
  12.          {
  13.                  return this.name;
  14.          }
  15.          //给军师下达一个命令，让他做什么
  16.          public void hufenghuangyu(String args)
  17.          {
  18.                  super.setChanged();
  19.                  super.notifyObservers(args);
  20.                  this.args=args;
  21.          }
  22.          //军师开始执行命令
  23.          public void kaishi()
  24.          {
  25.                  System.out.println(this.name+"开始---"+this.args);
  26.          }
  27. }
复制代码
小兵类：
  1. import java.util.Observable;
  2. import java.util.Observer;
  3. //描述一个兵类型
  4. public class xiaobing implements Observer
  5. {
  6.         //给每个小兵初始一个名字
  7.         private String name;
  8.         xiaobing(String name)
  9.         {
  10.                 this.name=name;
  11.         }
  12.         //让小兵具备偷窥的本领
  13.         public void update(Observable o, Object arg) {
  14.                 System.out.println(this.toString()+">>发现-"+o+"-正在-----"+arg);
  15.         }
  16.        
  17.         public String toString()
  18.          {
  19.                  return this.name;
  20.          }
  21.        
  22. }
复制代码
然后在主程序里开始运行，创建对应的对象，并让他们扯上关系。
  1. public class Main {

  3.         public static void main(String[] args) {
  4.                 //创建一个军师，诸葛亮
  5.                 jushi zgl=new jushi("诸葛孔明");
  6.                 //曹操选拔出三名侦察兵，准备去窥视诸葛亮
  7.                 xiaobing bing1=new xiaobing("曹操的侦查兵1");
  8.                 xiaobing bing2=new xiaobing("曹操的侦查兵2");
  9.                 xiaobing bing3=new xiaobing("曹操的侦查兵3");
  10.                 //三个小兵都都埋伏到诸葛亮的附近，只要他有什么作为，就会第一时间知道
  11.                 zgl.addObserver(bing1);
  12.                 zgl.addObserver(bing2);
  13.                 zgl.addObserver(bing3);
  14.                 //周瑜跟诸葛亮打了个赌，让他去呼风唤雨
  15.                 zgl.hufenghuangyu("呼风唤雨");
  16.                 //诸葛亮开始呼风唤雨
  17.                 zgl.kaishi();
  18.                
  19.                
  20.         }

  22. }
复制代码
运行结果：
曹操的侦查兵3>>发现-诸葛孔明-正在-----呼风唤雨
曹操的侦查兵2>>发现-诸葛孔明-正在-----呼风唤雨
曹操的侦查兵1>>发现-诸葛孔明-正在-----呼风唤雨
诸葛孔明开始---呼风唤雨
显而易见，诸葛亮还没有呼风唤雨的时候，曹操的侦察兵已经发现了这个目的，并且把诸葛亮要做的信息都捕获到。
观察者模式的优点：
观察者与被观察者之间是属于轻度关联关系，并且是抽象耦合的，这样，对于两者来说都比较容易进行扩展。
观察者模式是一种常用的触发机制，它形成一条触发链，依次对各个观察者的方法进行处理。但同时，这也算是观察者模式一个缺点，由于是链式触发，当观察者比较多的时候，性能问题是比较头疼的。并且，在链式结构中，比较容易出现循环引用的错误，造成系统假死。





欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2