设计模式之Observer：小孩在睡觉，醒来后要求吃东西

最新推荐文章于 2024-04-24 14:25:39 发布
最新推荐文章于 2024-04-24 14:25:39 发布
阅读量263 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhoujing_0424/article/details/48916323
版权

    这两天在学设计模式，那么从下面这个例子来入手吧！

    请模拟下列情形：

  • 小孩在睡觉
  • 醒来后要求吃东西
       1.设计方式一
           一个Child类，一个Dad类，Dad时刻监听Child，看其是否醒过来，若醒来则喂奶。     
package pack1;

class Child implements Runnable{
	private boolean WakeUp=false;

	public boolean isWakeUp() {
		return WakeUp;
	}

	public void setWakeUp(boolean wakeUp) {
		WakeUp = wakeUp;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			Thread.sleep(5000);//假设孩子睡5秒钟就醒来
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		this.WakeUp=true;
	}	
}

class Dad implements Runnable{
	Child c;
	
	Dad(Child c){
		this.c=c;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(!c.isWakeUp()){
			try {
				Thread.sleep(1000);//父亲每1秒就检查一次孩子有没有醒
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		feed(c);	
	}

	private void feed(Child c) {
		// TODO Auto-generated method stub
		System.out.println("feed child ...");	
	}
	
}
public class Design1 {
	public static void main(String[] args) {
	
		Child c=new Child();
		Dad d=new Dad(c);
		Thread threadChild=new Thread(c);
		Thread threadDad=new Thread(d);
		threadChild.start();
		threadDad.start();
	}
}
    上述设计方式虽然实现了基本的功能，但是由于Dad类一直主动监测Child是否醒来，浪费资源。一种简单的改进方式为，让Child醒来后主动调用Dad的Feed()方法，具体实现如下设计方式二。
     2.设计方式二
      Child类醒来主动调用Dad的Feed()方法。 
package pack2;

class Child implements Runnable{
	private Dad d;

	public Child(Dad d) {
		super();
		this.d = d;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			Thread.sleep(5000);//假设孩子睡5秒钟就醒来
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		d.feed(this);//孩子Child醒来主动调用Dad的feed()方法
	}	
}

class Dad {
	public void feed(Child c) {
		// TODO Auto-generated method stub
		System.out.println("feed child ...");
	}	
}

public class Design2 {
	public static void main(String[] args) {
		Dad d=new Dad();
		Child c=new Child(d);
		Thread threadChild=new Thread(c);
		threadChild.start();
	}

}
    设计方式二较好的完成了情形的模拟，节省了资源。我们考虑更复杂的一下情况，若孩子不同时间醒来，爸爸的响应要不同怎么办？
   3.设计方式三
    为了实现对不同时间孩子醒来的不同响应，我们把孩子醒来封装成一个事件类WakeUpEvent。 
package pack3;

class WakeUpEvent{
	private long time;
	private Object obj;
	
	public WakeUpEvent(long time, Object obj) {
		super();
		this.time = time;
		this.obj = obj;
	}
	public long getTime() {
		return time;
	}
	public void setTime(long time) {
		this.time = time;
	}
	public Object getObj() {
		return obj;
	}
	public void setObj(Object obj) {
		this.obj = obj;
	}
}

class Child implements Runnable{
	private Dad d;

	public Child(Dad d) {
		super();
		this.d = d;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			Thread.sleep(5000);//假设孩子睡5秒钟就醒来
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		d.ActionToWakeUp(new WakeUpEvent(System.currentTimeMillis(),this));//响应醒来事件
	}	
}

class Dad {
	public void ActionToWakeUp(WakeUpEvent wakeUpEvent) {
		// TODO Auto-generated method stub
		if(wakeUpEvent.getTime()<12){//不同时间对孩子的响应也不同
			System.out.println("feed child ...");
		}else{
			System.out.println("hug child ...");
		}
	}	
}

public class Design3 {
	public static void main(String[] args) {
		Dad d=new Dad();
		Child c=new Child(d);
		Thread threadChild=new Thread(c);
		threadChild.start();
	}
}
    设计方式三已经较全面的模拟了孩子醒来响应的基本情形，但此种方法的扩展性不好，例如，孩子醒来爷爷奶奶也有响应又怎么办？总不能来一个响应者就修改一次源代码吧？
    4.设计方式三
      使用接口，让所有响应者都实现WakeUpListener接口，并在Child类中使用响应者列表，使其可以动态添加响应者。 
package pack4;

import java.util.ArrayList;
import java.util.List;

class WakeUpEvent{
	private long time;
	private Object obj;
	
	public WakeUpEvent(long time, Object obj) {
		super();
		this.time = time;
		this.obj = obj;
	}
	public long getTime() {
		return time;
	}
	public void setTime(long time) {
		this.time = time;
	}
	public Object getObj() {
		return obj;
	}
	public void setObj(Object obj) {
		this.obj = obj;
	}
}

interface WakeUpListener{
	public void ActionToWakeUp(WakeUpEvent wakeUpEvent);
}

class Child implements Runnable{
	private List<WakeUpListener> wakeUpListeners=new ArrayList<WakeUpListener>(); 

	public void addWakeUpListener(WakeUpListener l){
		wakeUpListeners.add(l);
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			Thread.sleep(5000);//假设孩子睡5秒钟就醒来
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		//所有的响应者都对孩子醒来做出响应
		for(int i=0;i<wakeUpListeners.size();i++){
			WakeUpListener l=wakeUpListeners.get(i);
			l.ActionToWakeUp(new WakeUpEvent(System.currentTimeMillis(),this));
		}
	}	
}

class Dad implements WakeUpListener{
	public void ActionToWakeUp(WakeUpEvent wakeUpEvent) {
		// TODO Auto-generated method stub
		if(wakeUpEvent.getTime()<12){//不同时间对孩子的响应也不同
			System.out.println("Dad feed child ...");
		}else{
			System.out.println("Dad hug child ...");
		}
	}	
}

class GrandFather implements WakeUpListener{
	public void ActionToWakeUp(WakeUpEvent wakeUpEvent) {
		// TODO Auto-generated method stub
		if(wakeUpEvent.getTime()<12){//不同时间对孩子的响应也不同
			System.out.println("GrandFather feed child ...");
		}else{
			System.out.println("GrandFather hug child ...");
		}
	}	
}

public class Design4 {
	public static void main(String[] args) {
		Dad d=new Dad();
		GrandFather gf=new GrandFather();
		Child c=new Child();
		c.addWakeUpListener(d);//添加父亲响应者
		c.addWakeUpListener(gf);//添加爷爷响应者
		Thread threadChild=new Thread(c);
		threadChild.start();
	}
}
     此方法实现了动态添加响应者，它虽然不用修改Child类程序，但是还是要修改main()方法程序来添加响应者。
    5.设计方式五
     为了实现不修改任何程序而添加响应者，我们使用反射机制，通过读配置文件的方法来动态添加响应者。 
package pack5;

import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

class WakeUpEvent{
	private long time;
	private Object obj;
	
	public WakeUpEvent(long time, Object obj) {
		super();
		this.time = time;
		this.obj = obj;
	}
	public long getTime() {
		return time;
	}
	public void setTime(long time) {
		this.time = time;
	}
	public Object getObj() {
		return obj;
	}
	public void setObj(Object obj) {
		this.obj = obj;
	}
}

interface WakeUpListener{
	public void ActionToWakeUp(WakeUpEvent wakeUpEvent);
}

class Child implements Runnable{
	private List<WakeUpListener> wakeUpListeners=new ArrayList<WakeUpListener>(); 

	public void addWakeUpListener(WakeUpListener l){
		wakeUpListeners.add(l);
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			Thread.sleep(5000);//假设孩子睡5秒钟就醒来
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		//所有的响应者都对孩子醒来做出响应
		for(int i=0;i<wakeUpListeners.size();i++){
			WakeUpListener l=wakeUpListeners.get(i);
			l.ActionToWakeUp(new WakeUpEvent(System.currentTimeMillis(),this));
		}
	}	
}

public class Design5 {
	public static void main(String[] args) throws Exception {
		Child c=new Child();
		
		//创建配置文件
		File configFile=new File("wakeUpListeners.properties");
		Properties prop=new Properties();
		FileInputStream fis=new FileInputStream(configFile);
		prop.load(fis);
		
		for(int i=0;i<prop.size();i++){
			//获取响应者类名称
			String wakeUpListenerName=(String)prop.get("wakeUpListener"+(i+1));
			//根据类名称获取class文件
			Class clazz=Class.forName(wakeUpListenerName);
			WakeUpListener wakeUpListener=(WakeUpListener)clazz.newInstance();
			c.addWakeUpListener(wakeUpListener);		
		}
		fis.close();
		
		Thread threadChild=new Thread(c);
		threadChild.start();
	}
}
    以下分别为响应者类Dad、GrandFather、GrandMother，它们实现了统一的接口WakeUpListener，为了使用java的反射机制，都应为public类型的类。 
package pack5;

public class Dad implements WakeUpListener{
	public void ActionToWakeUp(WakeUpEvent wakeUpEvent) {
		// TODO Auto-generated method stub
		if(wakeUpEvent.getTime()<12){//不同时间对孩子的响应也不同
			System.out.println("Dad feed child ...");
		}else{
			System.out.println("Dad hug child ...");
		}
	}	
}
package pack5;

public class GrandFather implements WakeUpListener{
	public void ActionToWakeUp(WakeUpEvent wakeUpEvent) {
		// TODO Auto-generated method stub
		if(wakeUpEvent.getTime()<12){//不同时间对孩子的响应也不同
			System.out.println("GrandFather feed child ...");
		}else{
			System.out.println("GrandFather hug child ...");
		}
	}	
}

package pack5;

public class GrandMother implements WakeUpListener{
	public void ActionToWakeUp(WakeUpEvent wakeUpEvent) {
		// TODO Auto-generated method stub
		if(wakeUpEvent.getTime()<12){//不同时间对孩子的响应也不同
			System.out.println("GrandMother feed child ...");
		}else{
			System.out.println("GrandMother hug child ...");
		}
	}	
}
    下面为配置文件wakeUpListeners.properties。

    若后期还需添加其他的响应者，则只需实现WakeUpListener接口，并在配置文件中加入响应类的名称条目即可，实现了无需修改源代码而动态添加响应者。
    

zhoujing_0424
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式｜迭代器模式（Iterator）
weixin_44435110的博客
04-17 992
迭代器模式（Iterator）是一种行为设计模式，它允许在不暴露集合底层表示的情况下，顺序访问一个集合中的元素。这种模式在需要逐个处理集合中的元素，而又不希望暴露其内部结构的情况下非常有用。
设计模式之Observer
EckoTan的专栏
03-18 417
Observer
设计模式 - 观察者模式的6步演进 ( Observer ) 重点
weixin_42254177的博客
10-11 60
. 第1种 面向对象 ( 不停的循环, 所以有问题 ) . 第2种 改变完状态, 直接调用后续要执行的方法 可以简化很多的代码 . 问题就是耦合度太高 当一个child醒来之后, 有多个监听者, 每个监听者各有自己的处理逻辑 如果有新的观察者加进来, 得在多个地方加代码 . 第3种 类似责任链模式 让所有观察者实现同一个接口方法, 这样就可以遍历集合里的观察者对象, 依次调用接口方法 新加的观察者, 只需要实现接口方法, 然后创建一个对象, 再加入到观察者集合里就行了 . 你以为快完了, 其实才刚开始
设计模式之观察者模式(Observer模式)
supermary863的专栏
04-01 854
声明：本文参考了北京尚学堂马士兵老师的设计模式视频，表示感谢~~~1.问题的提出1) 小孩正在睡觉2）醒来的的时候，爸爸需要喂东西给他吃请编写代码模拟以上场景。这个很好实现，请参考以下java代码：/** * 小孩类 */ class Child implements Runnable{ private Dad d; public Child(Dad d) { this.d = d; } public void wakeUp() { d.feed(th
设计模式之Observer观察者模式
weixin_34015336的博客
09-07 62
观察者（Observer）模式 观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更...
设计模式:Observer（观察器）
03-03
本页内容上下文问题影响因素解决方案示例结果上下文相关模式上下文在面向对象的编程中，对象同时包含数据和行为，这两者一起表示业务域的特定方面。使用对象生成应用程序的优点之一是可以将所有数据操作封装在对象内...
C#设计模式之Observer观察者模式解决牛顿童鞋成绩问题示例
08-29
主要介绍了C#设计模式之Observer观察者模式解决牛顿童鞋成绩问题,简单讲述了观察者模式的原理并结合具体实例形式分析了使用观察者模式解决牛顿童鞋成绩问题的具体步骤相关操作技巧,并附带demo源码供读者下载参考,...
Java设计模式之观察者模式（Observer模式）介绍
09-03
主要介绍了Java设计模式之观察者模式（Observer模式）介绍,Java深入到一定程度，就不可避免的碰到设计模式(design pattern)这一概念,了解设计模式,将使自己对java中的接口或抽象类应用有更深的理解,需要的朋友可以...
PHP设计模式之观察者模式(Observer)详细介绍和代码实例
10-26
主要介绍了PHP设计模式之观察者模式(Observer)详细介绍和代码实例,需要的朋友可以参考下
设计模式- 建造者模式（Builder Pattern）结构|原理|优缺点|场景|示例
piaomiao_的博客
04-19 1039
建造者模式（Builder Pattern）是一种创建型设计模式，其主要目的是将复杂对象的构建过程与它的表示分离，使得相同的构建过程可以创建不同的表示。这种模式适用于创建包含多个可选部件、步骤复杂且可能需要逐步构建的复杂对象，它能将构建过程分解为多个独立的、可复用的步骤，使得对象的创建过程更加清晰、灵活且易于扩展。
每日一题：Spring 框架中都用到了哪些设计模式❓
lhcong_的博客
04-24 148
总之，Spring 框架中充分利用了许多设计模式，提供了良好的扩展性和灵活性，降低了代码的耦合度，提高了代码的可维护性。
设计模式-抽象工厂模式（Abstract Factory Pattern）结构|原理|优缺点|场景|示例
piaomiao_的博客
04-18 638
抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。这种模式的核心目的是将一组相关产品的创建过程封装起来，使得客户端可以使用一个统一的接口来创建这些产品家族中的任何产品，而无需关心具体的实现细节。抽象工厂模式特别适用于处理具有产品族的产品结构，其中产品族是指位于不同等级结构中的一组产品，它们之间可能存在一定的依赖或约束关系
设计模式之模板方法模式详解（下）
猫猫爱吃小鱼粮
04-18 633
设计模式之模板方法模式详解（下）
Java设计模式中策略模式
最新发布
Rsun2018的博客
04-24 166
在这个示例中，PaymentStrategy是策略接口，CreditCardPayment和PayPalPayment是具体策略。ShoppingCart是上下文，它持有一个对PaymentStrategy的引用，并在结账时调用支付方法。通过更改支付策略，我们可以在不修改ShoppingCart的情况下选择不同的支付方式。这种模式定义了一系列算法，并使这些算法可以相互替换，使得算法的变化独立于使用算法的客户。：负责维护一个对Strategy对象的引用，并且将客户请求委托给Strategy对象。
设计模式学习笔记 - 开源实战二（上）：从Unix开源开发学习应对大型复杂项目开发
chenjian723122704的专栏
04-18 967
本章，我们主要从设计原则和思想的角度，也可以说是设计开发的角度，来学习如何应对复杂软件的开发。主要总结了 7 点。封装与抽象分层与模块化基于接口通信高内聚、松耦合为扩展而设计KISS 首要原则最小惊奇原则（遵守开发规范）当然，这 7 点之间并不是相互独立的，有几点是相互支持的，例如 “高内聚、松耦合” 与抽象封装、分层模块化、基于接口通信。有几点是相互冲突的，比如 KISS 原则与为扩展而设计，这都需要根据实际情况去权衡。
每日三个JAVA经典面试题(四十)
Nekosann的博客
04-18 1085
设计模式可以在数据库操作中提高性能，尤其是在应用程序需要频繁访问数据库时。DAO模式将数据访问逻辑封装在单独的数据访问对象中，使得数据访问与业务逻辑分离。通过使用DAO模式，可以集中管理数据库连接、事务处理和SQL查询，从而提高代码的可维护性和性能。另外，DAO模式也有利于数据库操作的缓存管理，可以在DAO层实现缓存机制以减少数据库访问次数。对于需要频繁执行相似操作的场景，可以使用批量处理来减少数据库的访问次数。
设计模式-00 设计模式简介之几大原则
jxusthusiwen的专栏
04-23 776
设计模式相关的浅解，并运用modern cpp 来是实现，描述相关设计模式
【设计模式】9、facade 外观模式
呆呆的猫的博客
04-22 486
如果有一个复杂的系统, 内部有很多子系统, 可以用 facade 封装一层, 只暴露出用户关心的简单接口.
observer 设计模式 code c++
07-10
下是一个使用观察者（Observer）设计模式的示例代码（C++）： ```cpp #include <iostream> #include <vector> // 观察者接口 class Observer { public: virtual void update(const std::string& message) = 0; }; // 具体观察者A class ConcreteObserverA : public Observer { public: void update(const std::string& message) override { std::cout << "具体观察者A收到消息：" << message << std::endl; } }; // 具体观察者B class ConcreteObserverB : public Observer { public: void update(const std::string& message) override { std::cout << "具体观察者B收到消息：" << message << std::endl; } }; // 被观察者（主题）类 class Subject { private: std::vector<Observer*> observers; std::string message; public: void attach(Observer* observer) { observers.push_back(observer); } void detach(Observer* observer) { for (auto it = observers.begin(); it != observers.end(); ++it) { if (*it == observer) { observers.erase(it); break; } } } void notify() { for (auto observer : observers) { observer->update(message); } } void setMessage(const std::string& newMessage) { message = newMessage; notify(); } }; // 客户端代码 int main() { // 创建具体观察者对象 Observer* observerA = new ConcreteObserverA(); Observer* observerB = new ConcreteObserverB(); // 创建被观察者对象 Subject subject; // 注册观察者 subject.attach(observerA); subject.attach(observerB); // 设置消息并通知观察者 subject.setMessage("Hello World!"); // 取消注册观察者B subject.detach(observerB); // 设置新消息并通知观察者 subject.setMessage("Goodbye!"); delete observerA; delete observerB; return 0; } ``` 在上述示例代码中，我们定义了一个观察者接口 `Observer`，并要求具体的观察者类继承并实现该接口。具体的观察者类 `ConcreteObserverA` 和 `ConcreteObserverB` 分别定义了不同的更新行为。 被观察者（主题）类 `Subject` 包含一个观察者列表，并提供了注册、注销和通知观察者的方法。通过调用 `notify()` 方法，被观察者会遍历观察者列表，并调用每个观察者的 `update()` 方法来传递消息。 在客户端代码中，我们创建了具体的观察者对象，并将它们注册到被观察者中。然后，通过设置消息并调用被观察者的 `setMessage()` 方法来通知观察者。在示例中，我们设置了两条消息，并在第二条消息后注销了一个观察者。 运行代码将输出每个观察者收到的消息。 这个示例展示了观察者设计模式的基本结构和使用方式，并在 C++ 中实现了它。通过使用观察者模式，可以实现对象之间的松耦合，当一个对象的状态发生变化时，它的所有观察者都会得到通知并进行相应的处理。记得在程序结束时删除动态分配的内存。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值