设计模式_观察者模式

观察者模式官方定义是：

定义了对象之间的一对多依赖，当一个对象改变状态时，它所有的依赖者都会收到通知并更新。

用现实中的比喻就是:猎头（a）->猎头手中的人（b）的关系,首先b通知a我想加入时，a有消息就会通知b，b也可以通知a不用通知了，这里对应了观察者模式必须具备的三个方法

1. 增加(registeObserver)
2. 移除(removeObserver)
3. 更新(notifyObserver)

主题是有状态的对象，而观察者就是依赖者对象
实现的两种方式，推和拉 区别在于一种

• 推 是有状态的对象给依赖的对象传递信息，更新的时刻由 有状态的对象控制。
  
  • 缺陷：在于每次更新消息都会通知所有的依赖对象，无论其是否需要。
• 拉 则是由依赖者对象控制，更新由依赖者去控制。
  
  • 缺陷：在于依赖者不知道何时会更新消息，所以需要不断去抓取状态

代码如下：

package com.head_first;

import java.util.ArrayList;

interface Theme{
    void registerObserver(Observer ob);
    void removeObserver(Observer ob);
    void notifiyObserver();
}

class ThemeImp implements Theme{

    ArrayList<Observer> oblist;
    Object obj;
    boolean changed = false;

    public ThemeImp(){
        oblist = new ArrayList<Observer>();
    }

    public void registerObserver(Observer ob) {
        oblist.add(ob);

    }

    public void removeObserver(Observer ob) {
        oblist.remove(oblist.indexOf(ob));

    }

    public void notifiyObserver() {
        if(changed){
            for (Observer observer : oblist) {
                observer.update(obj);
            }
        }
        changed = false;
    }


    public void setObj(Object obj){
        this.obj = obj;
        changed = true; 
    }
}

interface Observer{
    void update(Object obj);
    void display();
}

class ObserverImp_1 implements Observer{
    Object obj;
    public ObserverImp_1(){
        obj = new Object();
    }

    public void update(Object obj) {
        obj = obj;
    }

    public void display() {

    }

}

class ObserverImp_2 implements Observer{
    Object obj;
    public ObserverImp_2(){
        obj = new Object();
    }

    public void update(Object obj) {
        obj = obj;
    }

    public void display() {

    }

}

public class ObserverPattern {
    public static void main(String[] args) {

        Theme themeImp = new ThemeImp();
        themeImp.registerObserver(new ObserverImp_1());
        themeImp.registerObserver(new ObserverImp_2());

    }
}

Java源码中涉及到观察者模式：Observable,Observer
以下是github上一个关于观察者模式，Java源码中的表述有点虎，有兴趣的可以自己去看下：地址

/**
 * Generic observer inspired by Java Generics and Collection by Naftalin & Wadler
 *
 * @param <S> Subject
 * @param <O> Observer
 * @param <A> Argument type
 */
public abstract class Observable<S extends Observable<S, O, A>, O extends Observer<S, O, A>, A> {

  protected List<O> observers;

  public Observable() {
    this.observers = new CopyOnWriteArrayList<O>();
  }

  public void addObserver(O observer) {
    this.observers.add(observer);
  }

  public void removeObserver(O observer) {
    this.observers.remove(observer);
  }

  /**
   * Notify observers
   */
  @SuppressWarnings("unchecked")
  public void notifyObservers(A argument) {
    for (O observer : observers) {
      observer.update((S) this, argument);
    }
  }
}