利用接口实现自定义监听事件以及观察者模式

最新推荐文章于 2024-07-26 02:46:42 发布

oIdmonk

最新推荐文章于 2024-07-26 02:46:42 发布

阅读量502

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/xjy9266/article/details/80947716

本文介绍了一种常用的设计模式——观察者模式，并通过Java代码示例详细展示了如何实现这一模式。观察者模式允许对象之间建立一对多的关系，当一个对象状态发生变化时，所有依赖于它的对象都会得到通知并被自动更新。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前段时间刚做过,事件一长就容易忘,赶紧记下来先

 1 package com.xujingyang.JT;
 2 
 3 public class Jt {
 4     interface Listenner{
 5         public void run();
 6     }
 7     
 8     
 9      class test{
10          Listenner listenner=null;
11         public void setOnRunListenner(Listenner ls){
12             listenner=ls;
13         }
14         
15         public void changeEvent(){
16             if(listenner!=null){
17                 listenner.run();
18             }
19         }
20     }
21     
22     
23     public static void main(String[] args) {
24         test t=new Jt().new test();
25         t.setOnRunListenner(new Listenner() {
26             
27             @Override
28             public void run() {
29                 System.out.println("我是run");
30             }
31         });
32         
33         t.changeEvent();
34     }
35 }

View Code

代码稍微修改,便是标准的观察者模式

观察者模式很好理解，类似于邮件订阅和RSS订阅，当我们浏览一些博客或wiki时，经常会看到RSS图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。其实，简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。先来看看关系图：

 1 package com.xujingyang.JT;
 2 
 3 import java.util.Iterator;
 4 import java.util.LinkedList;
 5 import java.util.List;
 6 
 7 public class Jt {
 8     interface Listenner {
 9         public void run();
10     }
11 
12     class Listenner1 implements Listenner {
13 
14         @Override
15         public void run() {
16             System.out.println("run1");
17         }
18 
19     }
20 
21     class Listenner2 implements Listenner {
22 
23         @Override
24         public void run() {
25             System.out.println("run2");
26         }
27 
28     }
29 
30     interface subject {
31         /* 增加观察者 */
32         public void add(Listenner observer);
33 
34         /* 删除观察者 */
35         public void del(Listenner observer);
36 
37         /* 通知所有的观察者 */
38         public void notifyObservers();
39 
40         /* 自身的操作 */
41         public void operation();
42     }
43     
44     abstract class AbstractSubject implements subject{
45 
46         List< Listenner> list=new LinkedList<Listenner>();
47         @Override
48         public void add(Listenner observer) {
49             list.add(observer);
50         }
51 
52         @Override
53         public void del(Listenner observer) {
54             list.remove(observer);
55         }
56 
57         @Override
58         public void notifyObservers() {
59             Iterator<Listenner> iterator = list.iterator();
60             while (iterator.hasNext()) {
61                 iterator.next().run();
62             }
63         }
64 
65      }
66 
67     
68     class mySubject extends AbstractSubject{
69 
70         @Override
71         public void operation() {
72             System.out.println("开始啦...");
73             notifyObservers();
74         }
75         
76     }
77     
78     
79 
80     public static void main(String[] args) {
81         subject s=new Jt().new mySubject();
82         s.add(new Jt().new Listenner1());
83         s.add(new Jt().new Listenner2());
84         s.operation();
85     }
86 }

View Code

结果: