`

java.util.Observable观察者模式

    博客分类:
  • Java
 
阅读更多

先举列子,对Observable有点感觉....

观察者为羊,被观察者为狼  模仿的场景为狼叫羊跑

代码如下:

1.被观察者类

package test.pattern.observer;  
import java.util.Observable;  
public class Wolf extends Observable{  
      
    private String name;  

    Wolf(String name) {  
        this.name = name;  
    }  
      
    public void cry(String state){  
        System.out.println(this.getName()+ " crying ");  
        this.setChanged();  
        this.notifyObservers(state);  
    }  

    public String getName() {  
        return name;  
    }  

    public void setName(String name) {  
        this.name = name;  
    }  
}

 

2.观察者类

package test.pattern.observer;  

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

public class Sheep implements Observer {  
      
    private String state = "eating";  
    private String name;  
      
    public Sheep(String name){  
        this.name = name;  
    }  
      
    public void update(Observable o, Object arg) {  
        // TODO Auto-generated method stub  
        Wolf wolf = (Wolf)o;  
        System.out.println(wolf.getName()+" crying and "+arg+" "+this.getName()+" running.....");  
        setState("running");  
    }  

    public String getState() {  
        return state;  
    }  

    public void setState(String state) {  
        this.state = state;  
    }  

    public String getName() {  
        return name;  
    }  

    public void setName(String name) {  
        this.name = name;  
    }  
}

 

3.测试

package test.pattern.observer;  

public class TestObserver {  

    public static void main(String[] args) {  
        Wolf wolf = new Wolf("wolf1");  
        Sheep sheep1 = new Sheep("sheep1");  
        Sheep sheep2 = new Sheep("sheep2");  
        Sheep sheep3 = new Sheep("sheep3");  
        //注册观察者,sheep1,sheep2加入,sheep3未加入  
        wolf.addObserver(sheep1);  
        wolf.addObserver(sheep2);  
        String wolfStat = "hungry";  
        //wolf begin cry  
        wolf.cry(wolfStat);  
    }  
}

 

4.结果:

wolf1 crying
wolf1 crying and hungry sheep2 running.....
wolf1 crying and hungry sheep1 running.....

------------------------------*****************-------------------------------

下面,再具体分析观察者模式每一块功能

------------------------------*****************-------------------------------

在Java中通过Observable类和Observer接口实现了观察者模式。Observer对象是观察者,Observable对象是被观察者。
1. 实现观察者模式
 
实现观察者模式非常简单,
[1]创建被观察者类,它继承自java.util.Observable类;
[2]创建观察者类,它实现java.util.Observer接口;
[3]对于被观察者类,
添加它的观察者:
void addObserver(Observer o)
addObserver()方法把观察者对象添加到观察者对象列表中。
当被观察事件发生时,执行:
setChanged();
notifyObservers();
setChange()方法用来设置一个内部标志位注明数据发生了变化;notifyObservers()方法会去调用观察者对象列表中
所有的Observer的update()方法,通知它们数据发生了变化。
只有在setChange()被调用后,notifyObservers()才会去调用update()。

[4]对于观察者类,实现Observer接口的唯一方法update
void update(Observable o, Object arg)
形参Object arg,对应一个由notifyObservers(Object arg);传递来的参数,
当执行的是notifyObservers();时,arg为null。
 
2.实例一
NumObserable是一个被观察者,当它的成员变量data的数值发生变化时,会通知所有的观察者。
NumObserable.java

package com.zj.observer;
import java.util.Observable;
public class NumObservable extends Observable {

    private int data = 0;

    public int getData() {
       return data;
    }
	
    public void setData(int i) {

       data = i;
       setChanged();
       notifyObservers();
    }
}

 NumObserver是观察者。当它的被观察者(NumObserable)执行了notifyObservers()后,它会执行uodate()方法。
NumObserver.java

package com.zj.observer;
import java.util.Observable;
import java.util.Observer;
public class NumObserver implements Observer{

    public void update(Observable o, Object arg) {
       NumObservable myObserable=(NumObservable) o;
       System.out.println("Data has changed to " +myObserable.getData());
    }

}

 测试类SingleTest,在这里将观察者加入到被观察者的观察列表中。
SingleTest.java

package com.zj.observer;
public class SingleTest {

    public static void main(String[] args) {

       NumObservable number = new NumObservable();
       number.addObserver(new NumObserver());
       number.setData(1);
       number.setData(2);
       number.setData(3);
    }
}

 结果:
Data has changed to 1
Data has changed to 2
Data has changed to 3

 

3.实例二
 
这个实例中,还是对data进行观察,拥有两个观察者,分别观察奇数和偶数的变化,
通过notifyObservers(arg)中的参数arg来识别通知信息。
被观察者NumsObservable.java

package com.zj.observers;
import java.util.Observable;
public class NumsObservable extends Observable {

    public final static Integer ODD = 1;
    public final static Integer EVEN = 2;
    private int data = 0;

    public int getData() {
       return data;
    }

    public void setData(int i) {

       data = i;
       Integer flag = EVEN;
       if ((data & 0x0001) == 1)
           flag = ODD;
       setChanged();
       notifyObservers(flag);
    }
}

 奇数观察者OddObserver.java

package com.zj.observers;
import java.util.Observable;
import java.util.Observer;
public class OddObserver implements Observer {

    public void update(Observable o, Object arg) {
       if (arg == NumsObservable.ODD) {
           NumsObservable myObserable = (NumsObservable) o;
           System.out.println("OddObserver:Data has changed to " + myObserable.getData());
       }
    }
}

 偶数观察者EvenObserver.java

package com.zj.observers;
import java.util.Observable;
import java.util.Observer;
public class EvenObserver implements Observer {

    public void update(Observable o, Object arg) {
       if (arg == NumsObservable.EVEN) {
           NumsObservable myObserable = (NumsObservable) o;
           System.out.println("EvenObserver:Data has changed to " + myObserable.getData());
       }
    }
}

 测试类MultiTest.java

package com.zj.observers;
public class MultiTest {

    public static void main(String[] args) {
       NumsObservable number = new NumsObservable();
       number.addObserver(new OddObserver());
       number.addObserver(new EvenObserver());
       number.setData(1);
       number.setData(2);
       number.setData(3);
    }
}

 结果:
OddObserver:Data has changed to 1
EvenObserver:Data has changed to 2
OddObserver:Data has changed to 3

------------------------------------*********************----------------------------

转载:http://blog.csdn.net/dada360778512/article/details/6977758

http://zhangjunhd.blog.51cto.com/113473/68949/

分享到:
评论

相关推荐

    Java内置观察者模式

    本文将深入探讨Java内置的观察者模式,包括其原理、实现方式以及实际应用。 ### 观察者模式的核心概念 1. **主题(Subject)**:被观察的对象,也就是发出通知的一方。在Java中,通常通过实现`java.util....

    观察者模式示例代码 android studio kotlin代码 基于java.uitl.*

    这个例子展示了如何在Android项目中使用Kotlin和`java.util.*`包中的观察者模式,虽然在现代Android开发中,我们更倾向于使用Kotlin的协程和LiveData等工具来实现异步通信和事件处理,但理解基本的观察者模式对于...

    java观察者模式介绍

    JDK里提供的observer设计模式的实现由java.util.Observable类和 java.util.Observer接口组成。从名字上可以清楚的看出两者在Observer 设计模式中分别扮演的角色:Observer是观察者角色,Observable是被观察目标...

    Java观察者模式代码

    在Java中,观察者模式的实现主要依赖于`java.util.Observable`类和`java.util.Observer`接口。`Observable`类代表被观察的对象,而`Observer`接口则表示观察者。下面我们将详细介绍如何在Java中实现观察者模式。 1....

    观察者模式源代码_java

    在Java中,观察者模式的实现通常依赖于`java.util.Observable`类和`java.util.Observer`接口。`Observable`类代表被观察的对象,而`Observer`接口则是观察者的接口。以下是对这两个关键组件的详细解释: 1. `...

    java 观察者模式 demo

    在Java中,观察者模式的实现主要依赖于Java的`java.util.Observable`类和`java.util.Observer`接口。`Observable`类代表被观察的对象,它可以有多个观察者;`Observer`接口则代表观察者,它们需要实现`update`方法来...

    java观察者模式观察者模式

    在Java中,`java.util.Observable`类和`java.util.Observer`接口提供了对观察者模式的内置支持。`Observable`类代表被观察的对象,它可以有多个观察者,而`Observer`接口则定义了观察者的通用行为。 ### `...

    java_util 工具包

    - **`Observer`接口和`Observable`类**:实现了观察者设计模式,用于事件监听和通知。 #### 四、总结 `java.util`包是Java语言中不可或缺的一部分,它提供的各种工具类和接口极大地丰富了Java的编程功能,使得...

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

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

    java.util源码-java-util:javautil源代码

    9. **事件模型**:`java.util.EventObject`和`java.util.Observable`类是观察者模式的基础,允许对象之间进行通信和事件处理。 10. **本地化**:`java.util.Locale`类用于表示语言环境,`java.text`包中的类用于...

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

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

    Java观察者模式

    Java观察者模式是一种行为设计模式,它允许定义对象之间的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。在Java中,这种模式被内置到`java.util.Observable`和`java.util....

    Java观察者模式代码全解析

    Java标准库提供了`java.util.Observable`和`java.util.Observer`接口,用于实现观察者模式。 首先,我们需要创建一个`Observable`类的子类,代表我们的主题。这个类需要维护一个观察者列表,并提供添加、删除观察者...

    java 观察者模式经典案例

    在Java中,观察者模式是通过Java的内置接口`java.util.Observer`和`java.util.Observable`来实现的。 在"java 观察者模式经典案例"中,我们以报社和读者为例来讲解这一模式。假设报社是被观察者(Observable),...

    观察者模式源码

    在Java中,观察者模式主要通过java.util.Observable和java.util.Observer接口来实现。 **观察者模式的核心概念:** 1. **主题(Subject)**:主题是被观察的对象,它可以是任何类型的对象,只要它可以发布状态变化...

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

    在Java中,观察者模式的实现通常基于Java的内置接口`java.util.Observer`和`java.util.Observable`。下面将详细解释观察者模式的概念、结构以及如何在Java中应用这个模式。 **观察者模式的核心概念:** 1. **主题...

    Java观察者模式案例

    在Java中,观察者模式的实现基于Java.util.Observable和Java.util.Observer接口。 Java的观察者模式通常包含两个主要角色: 1. **主题(Subject)**:这是被观察的对象,它可以是具体的类或抽象类。主题维护了一个...

    java观察者模式Demo

    在Java中,`java.util.Observable` 和 `java.util.Observer` 是内置支持观察者模式的类。 标题中的“java观察者模式Demo”指的是使用Java语言来演示观察者模式的应用。通常,这个Demo会包含一个可观察的对象...

    java观察者模式实例

    在Java中,`java.util.Observable`和`java.util.Observer`接口提供了内置的支持来实现观察者模式。`Observable`类代表被观察的对象,而`Observer`接口则表示观察者。让我们详细解析这个实例: 1. **定义主题...

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

    在Java中,观察者模式可以通过Java的内置接口`java.util.Observer`和`java.util.Observable`来实现。`Observer`接口代表观察者,而`Observable`类代表被观察的对象,也称为主题(Subject)。下面将详细介绍这两个...

Global site tag (gtag.js) - Google Analytics