观察者模式

最新推荐文章于 2025-06-16 09:51:36 发布

原创最新推荐文章于 2025-06-16 09:51:36 发布 · 111 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Java

设计模式专栏收录该内容

23 篇文章

订阅专栏

本文介绍了一种常用的设计模式——观察者模式，并通过一个房价变动的例子展示了如何使用Java实现该模式。观察者模式允许主题对象的状态变化自动通知多个观察者对象，从而实现一对多的依赖关系。

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化，会通知所有观察者对象，使他们能自动更新自己

import java.util.Observable;

public class House extends Observable {
    private int price = 1000000;

    public void modifyRoomRate(int price) {
        this.price += price;
        super.setChanged();
        notifyObservers(this.price);
    }
}

import java.util.Observable;
import java.util.Observer;

public class Buyer1 implements Observer {

    public void update(Observable paramObservable, Object paramObject) {
        System.out.println(paramObservable.countObservers()+"你好现在房价调整为  ：" + paramObject);
    }
}

import java.util.Observable;
import java.util.Observer;

public class Buyer2 implements Observer {

    public void update(Observable paramObservable, Object paramObject) {
        System.out.println(paramObservable.countObservers()+"你好现在房价调整为  ：" + paramObject);
    }
}

public class Client {

    public static void main(String[] args) {
        //被观察者
        House house = new House();
        //观察者
        Buyer1 buyer1 = new Buyer1();
        //观察者
        Buyer2 buyer2 = new Buyer2();
        
        house.addObserver(buyer1);
        house.addObserver(buyer2);
        
        house.modifyRoomRate(2000);
    }
}

Observable源代码：

package java.util;

public class Observable
{
  private boolean changed = false;
  private Vector obs = new Vector();

  public synchronized void addObserver(Observer paramObserver)
  {
    if (paramObserver == null)
      throw new NullPointerException();
    if (this.obs.contains(paramObserver))
      return;
    this.obs.addElement(paramObserver);
  }

  public synchronized void deleteObserver(Observer paramObserver)
  {
    this.obs.removeElement(paramObserver);
  }

  public void notifyObservers()
  {
    notifyObservers(null);
  }

  public void notifyObservers(Object paramObject)
  {
    Object[] arrayOfObject;
    synchronized (this)
    {
      if (!(this.changed))
        return;
      arrayOfObject = this.obs.toArray();
      clearChanged();
    }
    for (int i = arrayOfObject.length - 1; i >= 0; --i)
      ((Observer)arrayOfObject[i]).update(this, paramObject);
  }

  public synchronized void deleteObservers()
  {
    this.obs.removeAllElements();
  }

  protected synchronized void setChanged()
  {
    this.changed = true;
  }

  protected synchronized void clearChanged()
  {
    this.changed = false;
  }

  public synchronized boolean hasChanged()
  {
    return this.changed;
  }

  public synchronized int countObservers()
  {
    return this.obs.size();
  }
}

Observer 源代码：

package java.util;

public abstract interface Observer
{
  public abstract void update(Observable paramObservable, Object paramObject);
}