Java Observer设计模式

1 package observer;
2 //接口,用以实现小孩醒来时要做的事
3 public interface IWakeupListener {
4
5     public void ActionToWakeup(WakeupEvent eve);
6 }
1 package observer;
2 //Dad实现喂奶的动作
3 public class Dad  implements IWakeupListener{
4     @Override
5     public void ActionToWakeup(WakeupEvent e) {
6         System.out.println("儿子醒了,我要去喂奶了。。。");
7     }
8 }
 1 package observer;
 2 //狗实现叫的动作
 3 public class Dog implements IWakeupListener {
 4
 5     @Override
 6     public void ActionToWakeup(WakeupEvent e) {
 7         System.out.println("小主人醒了,我就汪汪叫。。。");
 8     }
 9
10 }
1 package observer;
2 //爷爷实现抱的动作
3 public class GrandFather implements IWakeupListener{
4
5     @Override
6     public void ActionToWakeup(WakeupEvent e) {
7         System.out.println("小孙子醒了,我要去抱抱!!!");
8     }
9 }
 1 package observer;
 2 //小孩的醒来事件:醒来时间,醒来地点,醒来的是谁
 3 public class WakeupEvent {
 4     private long time;
 5     private String location;
 6     private Child sorce;
 7
 8
 9     public WakeupEvent(long time, String location, Child sorce) {
10         super();
11         this.time = time;
12         this.location = location;
13         this.sorce = sorce;
14     }
15     public long getTime() {
16         return time;
17     }
18     public void setTime(long time) {
19         this.time = time;
20     }
21     public String getLocation() {
22         return location;
23     }
24     public void setLocation(String location) {
25         this.location = location;
26     }
27     public Child getSorce() {
28         return sorce;
29     }
30     public void setSorce(Child sorce) {
31         this.sorce = sorce;
32     }
33 }
 1 package observer;
 2 //小孩
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 import java.util.List;
 6
 7 public class Child implements Runnable{
 8
 9     private List<IWakeupListener> listener = new ArrayList<IWakeupListener>();
10
11     public void addWakeupListener(IWakeupListener l)
12     {
13         listener.add(l);
14     }
15
16 //-------------测试
17     @Override
18     public void run() {
19         try {
20             Thread.sleep(3000);
21         } catch (InterruptedException e) {
22             // TODO Auto-generated catch block
23             e.printStackTrace();
24         }
25         wakeup();
26     }
27
28     private void wakeup() {
29 //        Iterator<IWakeupListener> iter = listener.iterator();
30 //        while (iter.hasNext()) {
31 //            IWakeupListener l = iter.next();
32 //        }
33
34         for(Iterator<IWakeupListener> iter = listener.iterator();iter.hasNext();)
35         {
36             IWakeupListener l = iter.next();
37             l.ActionToWakeup(new WakeupEvent(System.currentTimeMillis(), "home", this));
38         }
39
40     }
41 //-------------测试end
42
43 }
配置文件:observer.properties,放在asset/config文件夹下1 observers=observer.Dad;observer.GrandFather;observer.Dog
 1 package observer;
 2 //解析.properties
 3 import java.io.IOException;
 4 import java.util.Properties;
 5
 6 public class PropertyProxy {
 7
 8     private Properties properties = new Properties();
 9     private static PropertyProxy instance=null;
10     public static PropertyProxy Instance()
11     {
12         if(instance==null)
13         {
14             instance = new PropertyProxy();
15         }
16         return instance;
17     }
18
19     public String getProperty(String path,String key)
20     {
21         try {
22             properties.load(PropertyProxy.class.getClassLoader().getResourceAsStream(path));
23         } catch (IOException e) {
24             // TODO Auto-generated catch block
25             e.printStackTrace();
26         }
27
28         return properties.getProperty(key);
29     }
30 }
 1 package observer;
 2
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 import java.util.List;
 6
 7 public class Child implements Runnable{
 8
 9     private List<IWakeupListener> listener = new ArrayList<IWakeupListener>();
10
11     public void addWakeupListener(IWakeupListener l)
12     {
13         listener.add(l);
14     }
15
16 //-------------测试
17     @Override
18     public void run() {
19         try {
20             Thread.sleep(3000);
21         } catch (InterruptedException e) {
22             // TODO Auto-generated catch block
23             e.printStackTrace();
24         }
25         wakeup();
26     }
27
28     private void wakeup() {
29 //        Iterator<IWakeupListener> iter = listener.iterator();
30 //        while (iter.hasNext()) {
31 //            IWakeupListener l = iter.next();
32 //        }
33
34         for(Iterator<IWakeupListener> iter = listener.iterator();iter.hasNext();)
35         {
36             IWakeupListener l = iter.next();
37             l.ActionToWakeup(new WakeupEvent(System.currentTimeMillis(), "home", this));
38         }
39
40     }
41 //-------------测试end
42
43 }
 1 package observer;
 2
 3 import oracle.net.aso.c;
 4
 5 public class Test {
 6
 7     public static void main(String[] args) {
 8         Child child = new Child();
 9
10         String[] observerArr = PropertyProxy.Instance().getProperty("asset/config/observer.properties", "observers").split(";");
11
12         for(String className: observerArr)
13         {
14             IWakeupListener l = null;
15             try {
16                 l = (IWakeupListener)(Class.forName(className).newInstance());
17             } catch (InstantiationException | IllegalAccessException
18                     | ClassNotFoundException e) {
19                 e.printStackTrace();
20             }
21             child.addWakeupListener(l);
22         }
23
24         new Thread(child).start();
25     }
26 }

时间: 2024-10-14 08:19:33

Java Observer设计模式的相关文章

(转)Java经典设计模式(3):十一种行为型模式(附实例和详解)

原文出处: 小宝鸽 Java经典设计模式共有21中,分为三大类:创建型模式(5种).结构型模式(7种)和行为型模式(11种). 本文主要讲行为型模式,创建型模式和结构型模式可以看博主的另外两篇文章:Java经典设计模式之五大创建型模式(附实例和详解).Java经典设计模式之七大结构型模式(附实例和详解). 行为型模式细分为如下11种:策略模式.模板方法模式.观察者模式.迭代子模式.责任链模式.命令模式.备忘录模式.状态模式.访问者模式.中介者模式.解释器模式. 接下来对11种行为型模式逐个进行介

第8篇-JAVA面向对象-设计模式Ⅳ

第8篇-JAVA面向对象-设计模式Ⅳ 每篇一句 : 想象是程序的创作之源 初学心得 : 平静的海洋练不出熟练的水手 (笔者:JEEP/711)[JAVA笔记 | 时间:2017-04-11| JAVA面向对象 Ⅳ] JAVA设计模式 什么是JAVA设计模式以及作用? 设计模式是一套被反复使用.多数人知晓的.经过分类编目的.代码设计经验的总结 使用设计模式是为了可重用代码.让代码更容易被他人理解.保证代码可靠性,本篇将介绍10种JAVA常用设计模式 1.JAVA 设计模式 - 单例设计模式 单例模

java/android 设计模式学习笔记(2)---观察者模式

这篇来讲一下观察者模式,观察者模式在实际项目中使用的也是非常频繁的,它最常用的地方是GUI系统.订阅--发布系统等.因为这个模式的一个重要作用就是解耦,使得它们之间的依赖性更小,甚至做到毫无依赖.以GUI系统来说,应用的UI具有易变性,尤其是前期随着业务的改变或者产品的需求修改,应用界面也经常性变化,但是业务逻辑基本变化不大,此时,GUI系统需要一套机制来应对这种情况,使得UI层与具体的业务逻辑解耦,观察者模式此时就派上用场了. PS:对技术感兴趣的同鞋加群544645972一起交流. 设计模式

转 分享我在阿里工作十年接触过Java框架设计模式

转 原文: 分享我在阿里工作十年接触过Java框架设计模式 一.前言 说起来设计模式,大家应该都耳熟能详,设计模式代表了软件设计的最佳实践,是经过不断总结提炼出来的代码设计经验的分类总结,这些模式或者可以简化代码,或者可以是代码逻辑开起来清晰,或者对功能扩展很方便…. 设计模式按照使用场景可以分为三大类:创建型模式(Creational Patterns).结构型模式(Structural Patterns).行为型模式(Behavioral Patterns). 创建型模式(Creationa

java/android 设计模式学习笔记(14)---外观模式

这篇博客来介绍外观模式(Facade Pattern),外观模式也称为门面模式,它在开发过程中运用频率非常高,尤其是第三方 SDK 基本很大概率都会使用外观模式.通过一个外观类使得整个子系统只有一个统一的高层的接口,这样能够降低用户的使用成本,也对用户屏蔽了很多实现细节.当然,在我们的开发过程中,外观模式也是我们封装 API 的常用手段,例如网络模块.ImageLoader 模块等.其实我们在开发过程中可能已经使用过很多次外观模式,只是没有从理论层面去了解它. 转载请注明出处:http://bl

java/android 设计模式学习笔记(10)---建造者模式

这篇博客我们来介绍一下建造者模式(Builder Pattern),建造者模式又被称为生成器模式,是创造性模式之一,与工厂方法模式和抽象工厂模式不同,后两者的目的是为了实现多态性,而 Builder 模式的目的则是为了将对象的构建与展示分离.Builder 模式是一步一步创建一个复杂对象的创建型模式,它允许用户在不知道内部构建细节的情况下,可以更精细地控制对象的构造流程.一个复杂的对象有大量的组成部分,比如汽车它有车轮.方向盘.发动机.以及各种各样的小零件,要将这些部件装配成一辆汽车,这个装配过

java/android 设计模式学习笔记(一)---单例模式

前段时间公司一些同事在讨论单例模式(我是最渣的一个,都插不上嘴 T__T ),这个模式使用的频率很高,也可能是很多人最熟悉的设计模式,当然单例模式也算是最简单的设计模式之一吧,简单归简单,但是在实际使用的时候也会有一些坑. PS:对技术感兴趣的同鞋加群544645972一起交流 设计模式总目录 java/android 设计模式学习笔记目录 特点 确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例. 单例模式的使用很广泛,比如:线程池(threadpool).缓存(cache).对

java/android 设计模式学习笔记(7)---装饰者模式

这篇将会介绍装饰者模式(Decorator Pattern),装饰者模式也称为包装模式(Wrapper Pattern),结构型模式之一,其使用一种对客户端透明的方式来动态的扩展对象的功能,同时它也是继承关系的一种替代方案之一,但比继承更加灵活.在现实生活中也可以看到很多装饰者模式的例子,或者可以大胆的说装饰者模式无处不在,就拿一件东西来说,可以给它披上无数层不一样的外壳,但是这件东西还是这件东西,外壳不过是用来扩展这个东西的功能而已,这就是装饰者模式,装饰者的这个角色也许各不相同但是被装饰的对

java/android 设计模式学习笔记(13)---享元模式

这篇我们来介绍一下享元模式(Flyweight Pattern),Flyweight 代表轻量级的意思,享元模式是对象池的一种实现.享元模式用来尽可能减少内存使用量,它适合用于可能存在大量重复对象的场景,缓存可共享的对象,来达到对象共享和避免创建过多对象的效果,这样一来就可以提升性能,避免内存移除和频繁 GC 等. 享元模式的一个经典使用案例是文本系统中图形显示所用的数据结构,一个文本系统能够显示的字符种类就是那么几十上百个,那么就定义这么些基础字符对象,存储每个字符的显示外形和其他的格式化数据