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

在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 = ; 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();
number.setData();
number.setData();
}
}
   结果:
   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 = ;
public final static Integer EVEN = ;
private int data = ; public int getData() {
return data;
} public void setData(int i) {
data = i;
Integer flag = EVEN;
if ((data & 0x0001) == )
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();
number.setData();
number.setData();
}
}
结果:
OddObserver:Data has changed to 

EvenObserver:Data has changed to 

OddObserver:Data has changed to 

应用Observer接口实践Observer模式的更多相关文章

  1. Java:应用Observer接口实践Observer模式

    本文出自“子 孑” 博客,原文链接:http://zhangjunhd.blog.51cto.com/113473/68949 在Java中通过Observable类和Observer接口实现了观察者 ...

  2. Java中使用Observer接口和Observable类实践Observer观察者模式

    在Java中通过Observable类和Observer接口实现了观察者模式.实现Observer接口的对象是观察者,继承Observable的对象是被观察者. 1. 实现观察者模式 实现观察者模式非 ...

  3. Java常用类库--观察者设计模式( Observable类Observer接口)

    如果要想实现观察者模式,则必须依靠java.util包中提供的Observable类和Observer接口. import java.util.* ; class House extends Obse ...

  4. 利用Java提供的Observer接口和Observable类实现观察者模式

    对于观察者模式,其实Java已经为我们提供了已有的接口和类.对于订阅者(Subscribe,观察者)Java为我们提供了一个接口,JDK源码如下: package java.util; public ...

  5. Java Observer接口和Observable类实现观察者模式

    对于观察者模式,其实Java已经为我们提供了已有的接口和类.对于订阅者(Subscribe,观察者)Java为我们提供了一个接口,JDK源码如下: package java.util; public ...

  6. 观察者设计模式( Observable类Observer接口)

    如果要想实现观察者模式,则必须依靠Java.util包中提供的Observable类和Observer接口. class House extends Observable{ // 表示房子可以被观察  ...

  7. Observer(观察者)模式

    1.概述 一些面向对象的编程方式,提供了一种构建对象间复杂网络互连的能力.当对象们连接在一起时,它们就可以相互提供服务和信息. 通常来说,当某个对象的状态发生改变时,你仍然需要对象之间能互相通信.但是 ...

  8. 责任型模式一:Observer(观察者)模式

    目的: Observer模式的宗旨是在多个对象之间定义一对多的关系,以便当一个对象状态改变时,其他所有依赖于这个对象的对象都能得到通知,并被自动更新.常用于业务逻辑层与表现层的分离. 需求:由GUI引 ...

  9. JavaScript设计模式与开发实践 - 策略模式

    引言 本文摘自<JavaScript设计模式与开发实践> 在现实中,很多时候也有多种途径到达同一个目的地.比如我们要去某个地方旅游,可以根据具体的实际情况来选择出行的线路. 如果没有时间但 ...

随机推荐

  1. Javascript:splice()方法实现对数组元素的插入、删除、替换及去重

    定义和用法 splice() 方法向/从数组中添加/删除项目,然后返回被删除的项目. 注释:该方法会改变原始数组. 语法: Array.prototype.splice(index,count[,el ...

  2. [Node.js] node-persist: localStorage on the server

    // Save data var storage = require('node-persist'); storage.init(); var people= require('./people.js ...

  3. 一年后重翻javascript

      回想下自己的工作历程  一年多的ios开发眨眼间就过去了  不过这一切还没有结束,紧随其后的便是前段开发,虽然顶点基础都没有,但是还是通过我的不懈努力最终成功转型,虽然刚开始是通过jq直接入门的 ...

  4. HashMap的分析(转)

    一.HashMap概述 HashMap基于哈希表的 Map 接口的实现.此实现提供所有可选的映射操作,并允许使用 null 值和 null 键.(除了不同步和允许使用 null 之外,HashMap  ...

  5. LDAP缓存命令

    启动cacao及实例: [root@rusky bin]# cd /home/ldap/iamldap/dsee6/cacao_2/cacao/bin [root@rusky bin]# ./caca ...

  6. 小学生之Log4j使用教程

    以前都是把所有日志都输出到一个文件下面,今天有个同事问想把某个包下的日志输出到 指定的地方,于是就在网上查了一些资料,总结一下,以免以后用到. 一.log4j是什么?  Log4j是一个开源的日志记录 ...

  7. Python 类 --基础与要点

    1:2.x与3.x区别: 2.x:老式类,都继承自object,继承机制为深度优先 3.x:新式类不需要写(object),继承机制为广度优先 2:类说明: 在定义类下用""&qu ...

  8. 高仿QQ即时聊天软件开发系列之二登录窗口界面

    继上一篇高仿QQ即时聊天软件开发系列之一开端之后,开始做登录窗口 废话不多说,先看效果,只有界面 可能还有一些细节地方没有做,例如那个LOGO嘛,不要在意这些细节 GIF虽短,可是这做起来真难,好吧因 ...

  9. zookeeper初体验之关于解决quartz重复执行任务的一种思路

    前阵子工作中遇到了一个很麻烦的问题.本人所在的项目组做了一个机遇quartz集群的任务系统.通俗点讲就是用quartz框架(quartz是一款能跑定时任务的框架支持复杂的时间表达式)来执行定时任务.但 ...

  10. effective_c++条款20,用pass-by-reference-to-const替换pass-by-value

    pass-by-value void f(A a); 1)导致复制是浪费资源 2)多态是导致对象切割 所以我们使用 void f(const A& a) 上面的话针对class,不针对基本类型 ...