java设计模式--事件监听器模式和观察者模式

刺骨的言语ヽ痛彻心扉 2022-06-12 21:06 204阅读 0赞

监听器模式：事件源经过事件的封装传给监听器，当事件源触发事件后，监听器接收到事件对象可以回调事件的方法

观察者模式：观察者(Observer)相当于事件监听者，被观察者(Observable)相当于事件源和事件，执行逻辑时通知observer即可触发oberver的update,同时可传被观察者和参数

**监听器模式demo**

1、首要定义事件源对象（事件源相当于单击按钮事件当中的按钮对象、属于被监听者）：

\[java\] [view plain][] [copy][view plain]

1.  **public****class** DemoSource \{     
2.  **private** Vector repository = **new** Vector();//监听自己的监听器队列   
3.  **public** DemoSource()\{\}     
4.  **public****void** addDemoListener(DemoListener dl) \{     
5.             repository.addElement(dl);     
6.      \}     
7.  **public****void** notifyDemoEvent() \{ //通知所有的监听器   
8.             Enumeration **enum** = repository.elements();     
9.  **while**(**enum**.hasMoreElements()) \{     
10.                    DemoListener dl = (DemoListener)**enum**.nextElement();     
11.                  dl.handleEvent(**new** DemoEvent(**this**));     
12.            \}     
13.     \}     
14. \}

2、其次定义事件（状态）对象（该事件对象包装了事件源对象、作为参数传递给监听器、很薄的一层包装类）：

\[java\] [view plain][] [copy][view plain]

1.  **public****class** DemoEvent **extends** java.util.EventObject \{     
2.  **public** DemoEvent(Object source) \{     
3.  **super**(source);//source—事件源对象—如在界面上发生的点击按钮事件中的按钮   
4.  //所有 Event 在构造时都引用了对象 "source"，在逻辑上认为该对象是最初发生有关 Event 的对象   
5.      \}     
6.  **public****void** say() \{     
7.             System.out.println("This is say method...");     
8.      \}     
9.  \}

3、最后定义我们的事件侦听器接口如下

\[java\] [view plain][] [copy][view plain]

1.  **public****interface** DemoListener **extends** java.util.EventListener \{     
2.  //EventListener是所有事件侦听器接口必须扩展的标记接口、因为它是无内容的标记接口、   
3.  //所以事件处理方法由我们自己声明如下：   
4.  **public****void** handleEvent(DemoEvent dm);     
5.  \}

监听器实现类

\[java\] [view plain][] [copy][view plain]

1.  **public****class** DemoListener1 **implements** DemoListener \{     
2.  **public****void** handleEvent(DemoEvent de) \{     
3.                System.out.println("Inside listener1...");     
4.                de.say();//回调   
5.         \}     
6.  \}

4、测试代码

\[java\] [view plain][] [copy][view plain]

1.  **public****class** TestDemo \{     
2.     DemoSource ds;     
3.  **public** TestDemo()\{     
4.  **try**\{     
5.           ds = **new** DemoSource();     
6.  //将监听器在事件源对象中登记：   
7.           DemoListener1 listener1 = **new** DemoListener1();     
8.           ds.addDemoListener(listener1);     
9.           ds.addDemoListener(**new** DemoListener() \{     
10. **public****void** handleEvent(DemoEvent event) \{     
11.             System.out.println("Method come from 匿名类...");     
12.           \}     
13.         \});     
14.        ds.notifyDemoEvent();//触发事件、通知监听器   
15.      \}**catch**(Exception ex)\{  
16.        ex.printStackTrace();  
17.        \}     
18.     \}     
19. **public****static****void** main(String args\[\]) \{     
20. **new** TestDemo();     
21.     \}     
22. \}

**观察者模式demo**

观察者

\[java\] [view plain][] [copy][view plain]

1.  **class** Watcher **implements** java.util.Observer \{     
2.  **public****void** update(java.util.Observable obj, Object arg) \{     
3.      System.out.println("Update() called, count is "
4.                                  + ((Integer) arg).intValue());     
5.  \}     
6.  \}

被观察者

\[java\] [view plain][] [copy][view plain]

1.  **class** BeingWatched **extends** java.util.Observable \{     
2.  **void** counter(**int** period) \{     
3.  **for**(; period<=0; period-- ) \{     
4.                  setChanged();     
5.                  notifyObservers(**new** Integer(period));     
6.  **try** \{     
7.                          Thread.sleep(100);     
8.                  \} **catch**( InterruptedException e) \{     
9.                    System.out.println("Sleep interrupeted" );     
10.                 \}     
11.         \}     
12. \}     
13. \};

测试

\[java\] [view plain][] [copy][view plain]

1.  **public****class** ObserverDemo \{     
2.  **public****static****void** main(String\[\] args) \{     
3.          BeingWatched beingWatched = **new** BeingWatched();//受查者   
4.          Watcher watcher = **new** Watcher();//观察者   
5.          beingWatched.addObserver(watcher);     
6.          beingWatched.counter(10);     
7.      \}     
8.  \}

查阅了一些相关的东东   
原来这两种api可以说都是基于：订阅-发布模式的事件/消息通知模式，二者应该都算是“推”方式吧，就是被监控者将消息通知给所有监控者。   
1、订阅：Observable.addObserver；  
事件源.addDemoListener（这个方法是自己定义的）。   
  
2、发布：Observable需要两步 ：setChanged()、notifyObservers(newValue);

事件源.notifyDemoEvent()（这个方法也是自己定义的）。

[view plain]: http://blog.csdn.net/dongnan591172113/article/details/8771441

发表评论取消回复

表情：

评论列表（有 0 条评论，204人围观）

还没有评论，来说两句吧...

相关阅读

相关 java设计模式：观察者模式

转载： [http://shenzhenchufa.blog.51cto.com/730213/161581][http_shenzhenchufa.blog.51cto

青旅半醒/ 2022年09月22日 15:50/ 0 赞/ 186 阅读

相关 java设计模式-----观察者模式

1.概念定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。 2.适用性（1）.当一个抽象模型有两个方面,其中一个

妖狐艹你老母/ 2022年09月18日 12:57/ 0 赞/ 252 阅读

相关 java设计模式--事件监听器模式和观察者模式

监听器模式：事件源经过事件的封装传给监听器，当事件源触发事件后，监听器接收到事件对象可以回调事件的方法观察者模式：观察者(Observer)相当于事件监听者，被观察者(Ob

刺骨的言语ヽ痛彻心扉/ 2022年06月12日 21:06/ 0 赞/ 205 阅读

相关 Java设计模式——观察者模式

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

以你之姓@/ 2022年06月04日 00:09/ 0 赞/ 203 阅读

相关观察者模式和监听器

一，类的四大基本关系： a.关联关系：如A类调用B类。 b.继承关系：如A类是B类的父类。 c.聚合关系：如装橘子的箱子，箱子是否存在与里面装没装橘子没有任何关系，

Love The Way You Lie/ 2022年05月29日 03:24/ 0 赞/ 208 阅读

相关 java设计模式-观察者模式

> 文章转自[汤高的Java设计模式（十五）—-观察者模式][Java_-] 观察者模式观察者模式定义结构

以你之姓@/ 2022年05月28日 02:28/ 0 赞/ 228 阅读

相关监听器：观察者设计模式

> 在学习编程知识的时候，我们知道在编程算法中有很多著名的编程思想，今天我要介绍的就是一种比较著名的编程思想---观察者设计模式思想，我们知道有时候我们需要监听

╰半橙微兮°/ 2022年05月20日 08:54/ 0 赞/ 183 阅读

相关 java设计模式-观察者模式

定义：使用head First 设计模式中提到的说法观察者模式定义了一个一对多的依赖关系，让一个或多个观察者对象监听一个主题对象。这样一来，当被观察者状态发生改

曾经终败给现在/ 2022年04月11日 06:47/ 0 赞/ 227 阅读

相关 JAVA设计模式——观察者模式

前言: 观察者模式，又可以称之为发布-订阅模式，顾名思义，简而言之我们可以理解成，7点半播放天气预报，电视里那个主持人就是发布者，也就是所谓的被观察者，我们这些听天气预报

向右看齐/ 2022年03月30日 05:25/ 0 赞/ 265 阅读

相关 Java 设计模式——观察者模式

一、前言好久没更新设计模式系列了，这周闲来无事，就水一把，介绍个简单的——`观察者模式`。所谓观察者模式，本质是就是发布与订阅，在日常生活中发布/订阅的例子有很多，

忘是亡心i/ 2021年12月20日 13:39/ 0 赞/ 264 阅读