观察者模式（observer模式）详解-mile米乐体育

模式的定义与特点

1. 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。符合依赖倒置原则。
2. 目标与观察者之间建立了一套触发机制。

1. 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
2. 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

模式的结构与实现

1. 模式的结构

1. 抽象主题（subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
2. 具体主题（concrete subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
3. 抽象观察者（observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
4. 具体观察者（concrete observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。

2. 模式的实现

 package net.biancheng.c.observer;  import java.util.*;  public class observerpattern {     public static void main(string[] args) {         subject subject = new concretesubject();         observer obs1 = new concreteobserver1();         observer obs2 = new concreteobserver2();         subject.add(obs1);         subject.add(obs2);         subject.notifyobserver();     } }  //抽象目标 abstract class subject {     protected list observers = new arraylist();      //增加观察者方法     public void add(observer observer) {         observers.add(observer);     }      //删除观察者方法     public void remove(observer observer) {         observers.remove(observer);     }      public abstract void notifyobserver(); //通知观察者方法 }  //具体目标 class concretesubject extends subject {     public void notifyobserver() {         system.out.println("具体目标发生改变...");         system.out.println("--------------");          for (object obs : observers) {             ((observer) obs).response();         }      } }  //抽象观察者 interface observer {     void response(); //反应 }  //具体观察者1 class concreteobserver1 implements observer {     public void response() {         system.out.println("具体观察者1作出反应！");     } }  //具体观察者1 class concreteobserver2 implements observer {     public void response() {         system.out.println("具体观察者2作出反应！");     } }

 具体目标发生改变... -------------- 具体观察者1作出反应！ 具体观察者2作出反应！

模式的应用实例

 package net.biancheng.c.observer;  import java.util.*;  public class rmbratetest {     public static void main(string[] args) {         rate rate = new rmbrate();         company watcher1 = new importcompany();         company watcher2 = new exportcompany();         rate.add(watcher1);         rate.add(watcher2);         rate.change(10);         rate.change(-9);     } }  //抽象目标：汇率 abstract class rate {     protected list companys = new arraylist();      //增加观察者方法     public void add(company company) {         companys.add(company);     }      //删除观察者方法     public void remove(company company) {         companys.remove(company);     }      public abstract void change(int number); }  //具体目标：人民币汇率 class rmbrate extends rate {     public void change(int number) {         for (company obs : companys) {             ((company) obs).response(number);         }     } }  //抽象观察者：公司 interface company {     void response(int number); }  //具体观察者1：进口公司 class importcompany implements company {     public void response(int number) {         if (number > 0) {             system.out.println("人民币汇率升值"   number   "个基点，降低了进口产品成本，提升了进口公司利润率。");         } else if (number < 0) {             system.out.println("人民币汇率贬值"   (-number)   "个基点，提升了进口产品成本，降低了进口公司利润率。");         }     } }  //具体观察者2：出口公司 class exportcompany implements company {     public void response(int number) {         if (number > 0) {             system.out.println("人民币汇率升值"   number   "个基点，降低了出口产品收入，降低了出口公司的销售利润率。");         } else if (number < 0) {             system.out.println("人民币汇率贬值"   (-number)   "个基点，提升了出口产品收入，提升了出口公司的销售利润率。");         }     } }

 人民币汇率升值10个基点，降低了进口产品成本，提升了进口公司利润率。 人民币汇率升值10个基点，降低了出口产品收入，降低了出口公司的销售利润率。 人民币汇率贬值9个基点，提升了进口产品成本，降低了进口公司利润率。 人民币汇率贬值9个基点，提升了出口产品收入，提升了出口公司的销售利润率。

 package net.biancheng.c.observer;  import java.util.*;  public class belleventtest {     public static void main(string[] args) {         belleventsource bell = new belleventsource();    //铃（事件源）         bell.addpersonlistener(new teacheventlistener()); //注册监听器（老师）         bell.addpersonlistener(new stueventlistener());    //注册监听器（学生）         bell.ring(true);   //打上课铃声         system.out.println("------------");         bell.ring(false);  //打下课铃声     } }  //铃声事件类：用于封装事件源及一些与事件相关的参数 class ringevent extends eventobject {     private static final long serialversionuid = 1l;     private boolean sound;    //true表示上课铃声,false表示下课铃声      public ringevent(object source, boolean sound) {         super(source);         this.sound = sound;     }      public void setsound(boolean sound) {         this.sound = sound;     }      public boolean getsound() {         return this.sound;     } }  //目标类：事件源，铃 class belleventsource {     private list listener; //监听器容器      public belleventsource() {         listener = new arraylist();     }      //给事件源绑定监听器     public void addpersonlistener(belleventlistener ren) {         listener.add(ren);     }      //事件触发器：敲钟，当铃声sound的值发生变化时，触发事件。     public void ring(boolean sound) {         string type = sound ? "上课铃" : "下课铃";         system.out.println(type   "响！");         ringevent event = new ringevent(this, sound);         notifies(event);    //通知注册在该事件源上的所有监听器     }      //当事件发生时,通知绑定在该事件源上的所有监听器做出反应（调用事件处理方法）     protected void notifies(ringevent e) {         belleventlistener ren = null;         iterator iterator = listener.iterator();         while (iterator.hasnext()) {             ren = iterator.next();             ren.heardbell(e);         }     } }  //抽象观察者类：铃声事件监听器 interface belleventlistener extends eventlistener {     //事件处理方法，听到铃声     public void heardbell(ringevent e); }  //具体观察者类：老师事件监听器 class teacheventlistener implements belleventlistener {     public void heardbell(ringevent e) {         if (e.getsound()) {             system.out.println("老师上课了...");         } else {             system.out.println("老师下课了...");         }     } }  //具体观察者类：学生事件监听器 class stueventlistener implements belleventlistener {     public void heardbell(ringevent e) {         if (e.getsound()) {             system.out.println("同学们，上课了...");         } else {             system.out.println("同学们，下课了...");         }     } }

 上课铃响！ 老师上课了... 同学们，上课了... ------------ 下课铃响！ 老师下课了... 同学们，下课了...

模式的应用场景

1. 对象间存在一对多关系，一个对象的状态发生改变会影响其他对象。
2. 当一个抽象模型有两个方面，其中一个方面依赖于另一方面时，可将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
3. 实现类似广播机制的功能，不需要知道具体收听者，只需分发广播，系统中感兴趣的对象会自动接收该广播。
4. 多层级嵌套使用，形成一种链式触发机制，使得事件具备跨域（跨越两种观察者类型）通知。

模式的扩展

1. observable类

1. void addobserver(observer o) 方法：用于将新的观察者对象添加到向量中。
2. void notifyobservers(object arg) 方法：调用向量中的所有观察者对象的 update() 方法，通知它们数据发生改变。通常越晚加入向量的观察者越先得到通知。
3. void setchange() 方法：用来设置一个 boolean 类型的内部标志位，注明目标对象发生了变化。当它为真时，notifyobservers() 才会通知观察者。

2. observer 接口

 package net.biancheng.c.observer;  import java.util.observer; import java.util.observable;  public class crudeoilfutures {     public static void main(string[] args) {         oilfutures oil = new oilfutures();         observer bull = new bull(); //多方         observer bear = new bear(); //空方         oil.addobserver(bull);         oil.addobserver(bear);         oil.setprice(10);         oil.setprice(-8);     } }  //具体目标类：原油期货 class oilfutures extends observable {     private float price;      public float getprice() {         return this.price;     }      public void setprice(float price) {         super.setchanged();  //设置内部标志位，注明数据发生变化         super.notifyobservers(price);    //通知观察者价格改变了         this.price = price;     } }  //具体观察者类：多方 class bull implements observer {     public void update(observable o, object arg) {         float price = ((float) arg).floatvalue();         if (price > 0) {             system.out.println("油价上涨"   price   "元，多方高兴了！");         } else {             system.out.println("油价下跌"   (-price)   "元，多方伤心了！");         }     } }  //具体观察者类：空方 class bear implements observer {     public void update(observable o, object arg) {         float price = ((float) arg).floatvalue();         if (price > 0) {             system.out.println("油价上涨"   price   "元，空方伤心了！");         } else {             system.out.println("油价下跌"   (-price)   "元，空方高兴了！");         }     } }

 油价上涨10.0元，空方伤心了！ 油价上涨10.0元，多方高兴了！ 油价下跌8.0元，空方高兴了！ 油价下跌8.0元，多方伤心了！