观察者设计模式

定义：定义对象间一对多的依赖关系，使得当每个对象改变状态，则所依赖于他的对象都会得到通知并自动更新。

观察者模式的结构：

在最基础的观察者模式中，包括四个角色。

抽象主题(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 {
   
2. 
   
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.         }
    
21. 
    
22. }

复制代码

运行结果：

曹操的侦查兵3>>发现-诸葛孔明-正在-----呼风唤雨

曹操的侦查兵2>>发现-诸葛孔明-正在-----呼风唤雨

曹操的侦查兵1>>发现-诸葛孔明-正在-----呼风唤雨

诸葛孔明开始---呼风唤雨

显而易见，诸葛亮还没有呼风唤雨的时候，曹操的侦察兵已经发现了这个目的，并且把诸葛亮要做的信息都捕获到。

观察者模式的优点：

观察者与被观察者之间是属于轻度关联关系，并且是抽象耦合的，这样，对于两者来说都比较容易进行扩展。

观察者模式是一种常用的触发机制，它形成一条触发链，依次对各个观察者的方法进行处理。但同时，这也算是观察者模式一个缺点，由于是链式触发，当观察者比较多的时候，性能问题是比较头疼的。并且，在链式结构中，比较容易出现循环引用的错误，造成系统假死。

观察者设计模式

定义：定义对象间一对多的依赖关系，使得当每个对象改变状态，则所依赖于他的对象都会得到通知并自动更新。

观察者模式的结构：

在最基础的观察者模式中，包括四个角色。

抽象主题(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 {
   
2. 
   
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.         }
    
21. 
    
22. }

复制代码

运行结果：

曹操的侦查兵3>>发现-诸葛孔明-正在-----呼风唤雨

曹操的侦查兵2>>发现-诸葛孔明-正在-----呼风唤雨

曹操的侦查兵1>>发现-诸葛孔明-正在-----呼风唤雨

诸葛孔明开始---呼风唤雨

显而易见，诸葛亮还没有呼风唤雨的时候，曹操的侦察兵已经发现了这个目的，并且把诸葛亮要做的信息都捕获到。

观察者模式的优点：

观察者与被观察者之间是属于轻度关联关系，并且是抽象耦合的，这样，对于两者来说都比较容易进行扩展。

观察者模式是一种常用的触发机制，它形成一条触发链，依次对各个观察者的方法进行处理。但同时，这也算是观察者模式一个缺点，由于是链式触发，当观察者比较多的时候，性能问题是比较头疼的。并且，在链式结构中，比较容易出现循环引用的错误，造成系统假死。