`
Caoyu_google
  • 浏览: 23180 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Java中观察者模式的使用

    博客分类:
  • java
阅读更多
   在一对多依赖的对象关系中, 如果这个'一'对象状态发生了变化,那么它所有依赖的'多'对象都应该被通知,然后做相应的变化,这就是观察者模式.  就如同'多'对象一直在观察'一'对象的状态变化一样.
      在观察者模式中最重要的俩个对象分别是:Observable和Observer对象.它们的关系可总结如下:
1. Observable和Observer对象是一对多的关系,也就是说一旦Observable对象状态变化,它就要负责通知所有和它有关系的Observer对象,然后做相应的改变.
1. Observable对象不会主动去通知各个具体的Observer对象其状态发生了变化,而是提供一个注册接口供Observer对象使用,任何一个Observer对象如果想要被通知,则可以使用这个接口来注册.
3. 在Observable中有一个集合和一个状态控制开关,所有注册了通知的Observer对象会被保存在这个集合中.这个控制开关就是用来控制Observable是否发生了变化,一旦发生了变化,就通知所有的Observer对象更新状态.

在java  api中分别提供了Observable对象:java.util.Observable和Observer接口:java.util.Observer. 下面用实例来实现一下观察者模式: 股票系统
所有的类如下:

StockData     (Observable对象,也就是所股票数据发生了变化,它就要通知所有和它有关系的交易实体做相应的变化)
BigBuyer       (Observer对象, 实现了Observer接口)
TradingFool   (Observer对象, 实现了Observer接口)
StockQuote   测试类
在这个例子中一旦StockData对象的状态发生了变化,那BigBuyer和TradingFool都应该受到通知:

StockData.java:
import java.util.Observable; 
 
public class StockData extends Observable 
    { 
    private String symbol; 
    private float close; 
    private float high; 
    private float low; 
    private long volume; 
 
    public StockData() 
        {} 
 
    public String getSymbol() 
        { 
        return symbol; 
        } 
 
    public float getClose() 
        { 
        return close; 
        } 
 
    public float getHigh() 
        { 
        return high; 
        } 
 
    public float getLow() 
        { 
        return low; 
        } 
 
    public long getVolume() 
        { 
        return volume; 
        } 
 
    public void sendStockData() 
        { 
        setChanged(); 
        notifyObservers(); 
        } 
 
    public void setStockData(String symbol,float close,float high,float low,long volume) 
        { 
        this.symbol = symbol; 
        this.close = close; 
        this.high = high; 
        this.low = low; 
        this.volume = volume; 
        sendStockData(); 
        } 
    } 
BigBuyer.java:
public class BigBuyer implements Observer 
    { 
    private String symbol; 
    private float close; 
    private float high; 
    private float low; 
    private long volume; 
 
    public BigBuyer(Observable observable) 
        { 
        observable.addObserver(this); //注册关系 
        } 
 
    public void update(Observable observable,Object args) 
        { 
        if(observable instanceof StockData) 
            { 
            StockData stockData = (StockData)observable; 
            this.symbol = stockData.getSymbol(); 
            this.close = stockData.getClose(); 
            this.high = stockData.getHigh(); 
            this.low = stockData.getLow(); 
            this.volume = stockData.getVolume(); 
            display(); 
            } 
        } 
 
    public void display() 
        { 
        DecimalFormatSymbols dfs = new DecimalFormatSymbols(); 
        DecimalFormat volumeFormat = new DecimalFormat("###,###,###,###",dfs); 
        DecimalFormat priceFormat = new DecimalFormat("###.00",dfs); 
        System.out.println("Big Buyer reports... "); 
        System.out.println("\tThe lastest stock quote for " + symbol + " is:"); 
        System.out.println("\t$" + priceFormat.format(close) + " per share (close)."); 
        System.out.println("\t$" + priceFormat.format(high) + " per share (high)."); 
        System.out.println("\t$" + priceFormat.format(low) + " per share (low)."); 
        System.out.println("\t" + volumeFormat.format(volume) + " shares traded."); 
        System.out.println(); 
        } 
    } 
TradingFool.java:
public class TradingFool implements Observer 
    { 
    private String symbol; 
    private float close; 
 
    public TradingFool(Observable observable) 
        { 
        observable.addObserver(this);//注册关系 
        } 
 
    public void update(Observable observable,Object args) 
        { 
        if(observable instanceof StockData) 
            { 
            StockData stockData = (StockData)observable; 
            this.symbol = stockData.getSymbol(); 
            this.close = stockData.getClose(); 
            display(); 
            } 
        } 
 
    public void display() 
        { 
        DecimalFormatSymbols dfs = new DecimalFormatSymbols(); 
        DecimalFormat priceFormat = new DecimalFormat("###.00",dfs); 
        System.out.println("Trading Fool says... "); 
        System.out.println("\t" + symbol + " is currently trading at $" + priceFormat.format(close) + " per share."); 
        System.out.println(); 
        } 
    } 
StokeQuote.java
public class StockQuotes 
    { 
    public static void main(String[] args) 
        { 
        System.out.println(); 
        System.out.println("-- Stock Quote Application --"); 
        System.out.println(); 
 
        StockData stockData = new StockData(); 
 
        // register observers... 
        new TradingFool(stockData); 
        new BigBuyer(stockData); 
 
        // generate changes to stock data... 
        stockData.setStockData("JUPM",16.10f,16.15f,15.34f,(long)481172); 
        stockData.setStockData("SUNW",4.84f,4.90f,4.79f,(long)68870233); 
        stockData.setStockData("MSFT",23.17f,23.37f,23.05f,(long)75091400); 
        } 
    } 
在测试类中我们可以看到俩个Observer对象都注册了Observable对象,而当Observable对象发生改变时,这俩个Observable对象就会做相应的更新了, 运行结果如下:
Big Buyer reports...  
    The lastest stock quote for JUPM is: 
    $16.10 per share (close). 
    $16.15 per share (high). 
    $15.34 per share (low). 
    481,172 shares traded. 
 
Trading Fool says...  
    JUPM is currently trading at $16.10 per share. 
 
Big Buyer reports...  
    The lastest stock quote for SUNW is: 
    $4.84 per share (close). 
    $4.90 per share (high). 
    $4.79 per share (low). 
    68,870,233 shares traded. 
 
Trading Fool says...  
    SUNW is currently trading at $4.84 per share. 
 
Big Buyer reports...  
    The lastest stock quote for MSFT is: 
    $23.17 per share (close). 
    $23.37 per share (high). 
    $23.05 per share (low). 
    75,091,400 shares traded. 
 
Trading Fool says...  
    MSFT is currently trading at $23.17 per share. 
我们通过Observable源码可以看到,其实Observable对象不关心具体的Observer的实例类型. 只要是实现了Observer接口的Observer对象都可以得到通知,这就为我们如果想要对模型进行扩展提供了方便,使Observable对象和Observer对象实现了松耦合. 如果我们需要添加一个新的Observer对象时,我们只要注册一下,当Observable对象发生变化时就可以得到通知,而不要做其他任何改变,非常方便.
分享到:
评论

相关推荐

    Java内置观察者模式

    观察者模式(Observer Pattern)是设计模式中的一种行为模式,它允许一个对象,当其状态发生改变时,能够自动通知所有依赖它的其他对象。在Java中,这种模式已经被内置到语言核心,使得开发者可以轻松地实现事件驱动...

    java观察者模式观察者模式

    观察者模式是设计模式中的一种行为模式,它在Java编程中有着广泛的应用。该模式的主要目的是定义对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式也被...

    java 设计模式 观察者模式 简单实例 包括测试test类

    观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件驱动或者发布...

    java观察者模式Demo

    标题中的“java观察者模式Demo”指的是使用Java语言来演示观察者模式的应用。通常,这个Demo会包含一个可观察的对象(Observable)和多个观察者(Observer),当可观察对象的状态发生变化时,会触发通知机制,使得...

    java 了解观察者模式

    观察者模式,也被称为发布-订阅(Publish-Subscribe)模式,是软件设计模式中的行为模式之一,主要用于对象间的一对多依赖关系管理。在Java中,观察者模式的实现主要依赖于`java.util.Observable`和`java.util....

    观察者模式java实现观察者设计模式

    观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。在Java中,我们可以利用Java提供的...

    Java观察者模式代码全解析

    在压缩包`ObserverModel`中,你应该能找到一个完整的Java观察者模式代码示例,包括主题和观察者的具体实现,以及如何使用它们进行交互。通过阅读和理解这段代码,你可以更深入地掌握观察者模式的运用。

    运用MVC模式及观察者模式的java小程序

    在这个名为“运用MVC模式及观察者模式的java小程序”的项目中,我们重点探讨了两种经典的设计模式:Model-View-Controller(MVC)模式和Observer(观察者)模式。这两种模式在JavaWeb开发中扮演着至关重要的角色。 ...

    java实现观察者模式

    观察者模式(Observer Pattern)是设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并被自动更新。这种模式常用于事件驱动的系统或者实时...

    Java 观察者模式的浅析

    ### Java观察者模式详解 #### 一、观察者模式概述 观察者模式是一种常用的设计模式,主要用于处理对象间的一对多依赖关系。当一个对象(主题)的状态发生变化时,所有依赖于它的对象(观察者)都会收到通知并自动...

    java 观察者模式 demo

    以下是一个简单的Java观察者模式的示例: ```java import java.util.Observable; import java.util.Observer; class WeatherData implements Observable { private float temperature; private float humidity; ...

    java设计模式之观察者模式

    观察者模式(Observer Pattern)是这些模式中的一种,它在多对一的关系中使用,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这个模式在事件驱动编程中非常常见,例如GUI组件间的交互、...

    java观察者模式实例

    5. **多态的应用**:通过使用接口,你可以有多个不同类型的观察者,它们可以有不同的更新行为,这就是多态性在观察者模式中的体现。每个观察者可以根据自己的需求对事件做出不同的响应。 6. **继承的角色**:在实例...

    设计模式--观察者模式java例子

    观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于事件驱动的系统或者...

    设计模式之观察者模式Java实现

    观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于事件驱动的系统或者...

    Java观察者模式案例

    以下是一个简单的Java观察者模式案例: ```java import java.util.ArrayList; import java.util.List; // 主题类(被观察者) class ObservableSubject extends Observable { private String state; public ...

    java内置的观察者模式demo

    在观察者模式中,被观察者是主题,它可以被许多观察者订阅。当被观察者的状态发生变化时,会自动调用所有已注册观察者的更新方法,传递变化的信息。这种模式可以实现松耦合,使得系统组件能够独立地工作和响应变化。...

    java 子线程通过观察者模式通知主线程

    在Java中,`java.util.Observable`类和`java.util.Observer`接口提供了对观察者模式的支持。 1. **`Observable`类**:代表被观察的对象,可以注册多个观察者,并在状态改变时通知它们。`Observable`类提供了`...

    Java观察者模式代码

    观察者模式(Observer Pattern)是设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并被自动更新。这种模式常用于事件驱动的系统或者需要...

Global site tag (gtag.js) - Google Analytics