设计模式_09_观察者模式

1.为什么会有观察者模式

当我们编写程序时，肯定会遇到一对多的对象依赖关系，当一个对象的状态发生变化时，和它有关联的对象也会随之发生变化，与其主动的检测主题对象的变化，不如被动的观察，当观察的主题对象行为或状态发生变化时由它通知每一个观察者，在主题对象状态变化时紧接着观察者做出相应的改变。

定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。. 这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。

2.使用场景

• 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。
• 对象间存在一对多关系，一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。
• 一个对象必须通知其他对象，而并不知道这些对象是谁。
• 需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。

总的来说，如果一个对象的状态变化需要通知其他对象，并且这些对象的数量和类型可能会发生变化，那么观察者模式就是一个适合的选择

3.四要素

• 抽象主题：被观察的对象，维护着一个观察者列表。
• 具体主题：抽象主题的具体实现类。它维护着观察者列表，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
• 抽象观察者：一个抽象类或接口，抽象观察者需要实现一个抽象更新方法，当收到主题的通知时，调用该方法进行更新操作。
• 具体观察者：具体观察者是抽象观察者的具体实现类。它实现了更新方法，以便在得到目标的更改通知时需要执行的具体操作。

4.观察者模式的设计

我们通过下面的实例来演示观察者模式的使用。
使用三个类 Subject、Observer 和 Client。Subject 对象带有绑定观察者和解绑观察者的方法。我们创建 Subject 类、Observer 抽象类和扩展了抽象类 Observer 的实体类。
观察者UML图

Subject

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

public class Subject {
   
   private List<Observer> observers 
      = new ArrayList<Observer>();
   private int state;
 
   public int getState() {
      return state;
   }
 
   public void setState(int state) {
      this.state = state;
      notifyAllObservers();
   }
 
   public void attach(Observer observer){
      observers.add(observer);      
   }
   public void remove(Observer observer){
   	  observer.remove(observer);
   }
   public void notifyAllObservers(){
      for (Observer observer : observers) {
         observer.update();
      }
   }  
}

Observer

public interface Observer {
   public abstract void update();
}

class BinaryObserver implements Observer{

   @Override
   public void update() {
      System.out.println( "Binary String: " 
      + Integer.toBinaryString( subject.getState() ) ); 
   }
}
class OctalObserver implements Observer{

   @Override
   public void update() {
     System.out.println( "Octal String: " 
     + Integer.toOctalString( subject.getState() ) ); 
   }
}
class HexaObserver implements Observer{
 
   @Override
   public void update() {
      System.out.println( "Hex String: " 
      + Integer.toHexString( subject.getState() ).toUpperCase() ); 
   }
}

测试

public class ObserverPatternDemo {
   public static void main(String[] args) {
      Subject subject = new Subject();
 
      Observer ho = new HexaObserver();
      Observer oo = new OctalObserver();
      Observer bo = new BinaryObserver();
 	
 	  subject.attach(ho); 
 	  subject.attach(oo);
 	  subject.attach(bo);
 	  
      System.out.println("First state change: 15");   
      subject.setState(15);
      System.out.println("Second state change: 10");  
      subject.setState(10);
   }
}

结果

First state change: 15
Hex String: F
Octal String: 17
Binary String: 1111
Second state change: 10
Hex String: A
Octal String: 12
Binary String: 1010

参考：
观察者模式
观察者模式详解