小孩睡觉模拟（Observer设计模式）

最新推荐文章于 2021-03-16 01:50:24 发布
最新推荐文章于 2021-03-16 01:50:24 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： 架构及设计模式 文章标签： 设计模式 string class button interface import
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rongyongfeikai2/article/details/7645310
版权

一小孩睡觉，醒了要东西吃，父亲就得喂他东西。

典型的模拟题。代码如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class Child{
	
	private boolean wakenUp;
	
	public Child() {
		
		try {
			System.out.println("Child sleep.");
		
			//用新的线程模拟小孩睡觉，防止在构造函数阻塞了
			ExecutorService executor=Executors.newSingleThreadExecutor();
			executor.execute(new Runnable(){
				
				public void run(){
					
					try {
						Thread.sleep(10000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					wakeup();
				}
			});
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public void wakeup() {
		
		System.out.println("Child wake up.");
		wakenUp = true;
	}

	public boolean isWakenUp() {
		
		return wakenUp;
	}
}
class Dad implements Runnable{
	
	private Child child = null;
	
	public Dad(Child child) {
		
		this.child = child;
	}
	public void run() {
		
		while(!this.child.isWakenUp()) {
			
			try {
				System.out.println("Dad wait.");
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		feed();
	}
	
	public void feed() {
		
		System.out.println("feed child.");
	}
}
public class Main {

	public static void main(String[] args){
		
		Child child = new Child();
		new Thread(new Dad(child)).start();
	}
}

这种题目不幼稚，就算开发多年的人都该时不时的思考一下。能做山珍海味的固然是好厨师，但能把家常的萝卜白菜给炖出了美妙的味道，那才是高手。

输出为：

Child sleep.
Dad wait.
Dad wait.
Dad wait.
Dad wait.
Dad wait.
Dad wait.
Dad wait.
Dad wait.
Dad wait.
Dad wait.
Child wake up.
feed child.

但是，每隔一秒让父亲监测显然是不够人性化的，那么就需要将主动变为被动。在Child类中加入对Dad类的引用，从而使得在孩子醒时，主动调用Dad类的feed方法。

代码如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class Child{
	
	private Dad dad=new Dad();
	public Child(){
		
		System.out.println("Child sleep.");
		
		ExecutorService exeService = Executors.newSingleThreadExecutor();
		exeService.execute(new Runnable(){
			
			public void run() {
				
				try {
					Thread.sleep(10000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				wakeup();
				
				//化主动监测为被动
				dad.feed();
			}
		});
	}
	public void wakeup(){
		
		System.out.println("Child wake up.");
	}
}
class Dad{
	
	public void feed() {
		
		System.out.println("Feed child.");
	}
}
public class Main{
	
	public static void main(String[] args){
		
		Child child=new Child();
	}
}

输出为：

Child sleep.
Child wake up.
Feed child.

第三版更灵活的程序，有事件，和不同的观察者。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class WakeupEvent {
	
	private long time;
	private String location;
	private Child source;
	
	public WakeupEvent(long time,String location,Child source){
		
		this.time = time;
		this.location = location;
		this.source = source;
	}

	public long getTime() {
		return time;
	}

	public void setTime(long time) {
		this.time = time;
	}

	public String getLocation() {
		return location;
	}

	public void setLocation(String location) {
		this.location = location;
	}

	public Child getSource() {
		return source;
	}

	public void setSource(Child source) {
		this.source = source;
	}
}
class Child{
	
	private Family family=null;
	
	public Child(Family family){
		
		this.family=family;
		System.out.println("Child sleep.");
		
		ExecutorService exeService = Executors.newSingleThreadExecutor();
		exeService.execute(new Runnable(){
			
			public void run() {
				
				try {
					Thread.sleep(10000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				wakeup();
				
				//化主动监测为被动
				Child.this.family.wakeupAction(new WakeupEvent(System.currentTimeMillis(),"bed",Child.this));
			}
		});
	}
	public void wakeup(){
		
		System.out.println("Child wake up.");
	}
}
interface Family{
	
	public void wakeupAction(WakeupEvent wakeup);
}
class Dad implements Family{
	
	public void wakeupAction(WakeupEvent wakeup){
		
		//根据WakeupEvent的不同情况作出不同的反应
		//代码略
		System.out.println("Feed Child.");
	}
}
class GrandFather implements Family{

	@Override
	public void wakeupAction(WakeupEvent wakeup) {
		
		System.out.println("Hug child.");
	}
}
public class Main{
	
	public static void main(String[] args){
		
		Child child=new Child(new GrandFather());
	}
}

如果有多个观察者，可以用List的方式，上面的程序只有1个观察者。

输出为：

Child sleep.
Child wake up.
Hug child.

多个观察者的代码如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.*;
class WakeupEvent {
	
	private long time;
	private String location;
	private Child source;
	
	public WakeupEvent(long time,String location,Child source){
		
		this.time = time;
		this.location = location;
		this.source = source;
	}

	public long getTime() {
		return time;
	}

	public void setTime(long time) {
		this.time = time;
	}

	public String getLocation() {
		return location;
	}

	public void setLocation(String location) {
		this.location = location;
	}

	public Child getSource() {
		return source;
	}

	public void setSource(Child source) {
		this.source = source;
	}
}
class Child{
	
	private List<Family> familyList=null;
	
	public Child(List<Family> list){
		
		this.familyList=list;
		System.out.println("Child sleep.");
		
		ExecutorService exeService = Executors.newSingleThreadExecutor();
		exeService.execute(new Runnable(){
			
			public void run() {
				
				try {
					Thread.sleep(10000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				wakeup();
				
				//化主动监测为被动
				for(int i=0;i<familyList.size();i++)
				{
					familyList.get(i).wakeupAction(new WakeupEvent(System.currentTimeMillis(),"bed",Child.this));
				}
			}
		});
	}
	public void wakeup(){
		
		System.out.println("Child wake up.");
	}
}
interface Family{
	
	public void wakeupAction(WakeupEvent wakeup);
}
class Dad implements Family{
	
	public void wakeupAction(WakeupEvent wakeup){
		
		//根据WakeupEvent的不同情况作出不同的反应
		//代码略
		System.out.println("Feed Child.");
	}
}
class GrandFather implements Family{

	@Override
	public void wakeupAction(WakeupEvent wakeup) {
		
		System.out.println("Hug child.");
	}
}
public class Main{
	
	public static void main(String[] args){
		
		List<Family> list=new ArrayList<Family>();
		list.add(new Dad());
		list.add(new GrandFather());
		Child child=new Child(list);
	}
}

输出为：

Child sleep.
Child wake up.
Feed Child.
Hug child.

当然，在代码中添加观察者还是不够灵活，最好的方式是把观察者配置在**.properties文件中，从配置文件中读取，从而添加观察者。

那么代码修改成为如下的方式。

import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.*;
class WakeupEvent {
	
	private long time;
	private String location;
	private Child source;
	
	public WakeupEvent(long time,String location,Child source){
		
		this.time = time;
		this.location = location;
		this.source = source;
	}

	public long getTime() {
		return time;
	}

	public void setTime(long time) {
		this.time = time;
	}

	public String getLocation() {
		return location;
	}

	public void setLocation(String location) {
		this.location = location;
	}

	public Child getSource() {
		return source;
	}

	public void setSource(Child source) {
		this.source = source;
	}
}
class Child{
	
	private List<Family> familyList=null;
	
	public Child(List<Family> list){
		
		this.familyList=list;
		System.out.println("Child sleep.");
		
		ExecutorService exeService = Executors.newSingleThreadExecutor();
		exeService.execute(new Runnable(){
			
			public void run() {
				
				try {
					Thread.sleep(10000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				wakeup();
				
				//化主动监测为被动
				for(int i=0;i<familyList.size();i++)
				{
					familyList.get(i).wakeupAction(new WakeupEvent(System.currentTimeMillis(),"bed",Child.this));
				}
			}
		});
	}
	public void wakeup(){
		
		System.out.println("Child wake up.");
	}
}
interface Family{
	
	public void wakeupAction(WakeupEvent wakeup);
}
class Dad implements Family{
	
	public void wakeupAction(WakeupEvent wakeup){
		
		//根据WakeupEvent的不同情况作出不同的反应
		//代码略
		System.out.println("Feed Child.");
	}
}
class GrandFather implements Family{

	@Override
	public void wakeupAction(WakeupEvent wakeup) {
		
		System.out.println("Hug child.");
	}
}
public class Main{
	
	public static void main(String[] args){
		
		List<Family> list=new ArrayList<Family>();
	    //从配置文件中读取观察者
		Properties props = new Properties();
		try {
			props.load(Main.class.getClassLoader().getResourceAsStream("Observer.properties"));
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		String[] obersvers = props.getProperty("Observers").split(",");
		for(String s:obersvers) {
			
			try {
				list.add((Family)Class.forName(s).newInstance());
			} catch (InstantiationException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		
		Child child=new Child(list);
	}
}

配置文件Oberser.properties的内容为：

Observers=Dad,GrandFather

运行结果为：

Child sleep.
Child wake up.
Feed Child.
Hug child.

观察者模式还用在了java.awt.Button中，Button中有一系列的观察者ActionListener，在button被按下时调用这一系列ActionListener的actionPerformed方法。

代码如下：

import java.util.*;
class Button {
	
	private List<ActionListener> list = new ArrayList<ActionListener> ();
	
	public void addActionListener(ActionListener actionListener){
		
		list.add(actionListener);
	}
	public void pressButton() {
		
		for(int i=0;i<list.size();i++) {
			
			list.get(i).actionPerformed(new ActionEvent(this));
		}
	}
}
interface ActionListener {
	
	public void actionPerformed(ActionEvent e);
}
class MyActionListener implements ActionListener {

	@Override
	public void actionPerformed(ActionEvent e) {
		
		System.out.println(e.getSource()+"按钮被按了");
	}
}
class ActionEvent {
	
	private Button source;
	
	public ActionEvent(Button btn){
		
		this.source=btn;
	}
	public Object getSource() {
		
		return this.source;
	}
}
public class Test {
	
	public static void main(String[] args) {
		
		Button btn = new Button();
		btn.addActionListener(new MyActionListener());
		
		//当按钮被按下时
		btn.pressButton();
	}
}
rongyongfeikai2
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
委托、事件与Observer设计模式
01-10
委托、事件和Observer设计模式是面向对象编程中的关键概念，特别是在C#中有着广泛的应用。本文将深入探讨这三个概念，并通过实例帮助初学者理解和掌握它们。 首先，让我们从委托（Delegate）开始。委托在C#中可以被...
设计模式:Observer（观察器）
03-03
本页内容上下文问题影响因素解决方案示例结果上下文相关模式上下文在面向对象的编程中，对象同时包含数据和行为，这两者一起表示业务域的特定方面。使用对象生成应用程序的优点之一是可以将所有数据操作封装在对象内...
设计模式之Observer：小孩在睡觉，醒来后要求吃东西
静墨的博客
10-05 264
这两天在学设计模式，那么从下面这个例子来入手吧！     请模拟下列情形： 小孩在睡觉 醒来后要求吃东西        1.设计方式一            一个Child类，一个Dad类，Dad时刻监听Child，看其是否醒过来，若醒来则喂奶。           package pack1; class Child implements Runnable{ privat
设计模式之Observer
EckoTan的专栏
03-18 427
Observer
java设计模式之——观察者模式observer （附带读取配置文件）
血煞长虹 的专栏
03-16 279
参考：根据马士兵老师课程整理。 目的：相互交流学习，日后便于自己查看。 要求：小孩睡醒后，要吃东西，监护者对小孩做出一些列反映。据此模拟为程序。 延伸：小偷偷东西，有望风的小弟看风，也比较适合用这个设计模式
设计模式 - 观察者模式的6步演进 ( Observer ) 重点
weixin_42254177的博客
10-11 64
. 第1种 面向对象 ( 不停的循环, 所以有问题 ) . 第2种 改变完状态, 直接调用后续要执行的方法 可以简化很多的代码 . 问题就是耦合度太高 当一个child醒来之后, 有多个监听者, 每个监听者各有自己的处理逻辑 如果有新的观察者加进来, 得在多个地方加代码 . 第3种 类似责任链模式 让所有观察者实现同一个接口方法, 这样就可以遍历集合里的观察者对象, 依次调用接口方法 新加的观察者, 只需要实现接口方法, 然后创建一个对象, 再加入到观察者集合里就行了 . 你以为快完了, 其实才刚开始
php设计模式 Observer(观察者模式)
10-28
在PHP编程中，设计模式是一种解决特定问题、实现可复用和高效代码结构的方法。观察者模式（Observer Pattern）是其中一种常见模式，它遵循“发布-订阅”原则，用于建立对象之间的一对多依赖关系。当一个对象的状态...
C++设计模式之观察者模式（Observer）
08-27
C++设计模式之观察者模式（Observer） 观察者模式（Observer）是一种常用的设计模式，它主要用于解决对象之间的一对多关系问题。在这种模式中，一个对象（被观察者）维护一个观察者对象的集合，当被观察者对象变化...
DWR+Spring+Hibernate+Oracle在MyEclipse搭建框架示例
卧龙居
03-07 1135
IDE为MyEclipse。 首先新建一个项目，取名为QSWB（奇傻无比）。我们用c3p0连接池连接Oracle数据库，所以首先准备好c3p0的jar包和oracle的jar包。 分别为：c3p0-0.9.1.2.jar，c3p0-0.9.1.jar，classes12.jar。放入WEB-INF的lib包中。 项目建立文件夹如下图所示： 然后，在项目上点击右键，MyEclipse->A
设计模式学习笔记之装饰器模式
卧龙居
08-07 844
所谓装饰器模式，即可以灵活的为已有的功能添加新的功能。具体的实例如下： 有一个变形金刚的抽象类： package com.DesginPolicyLearn.Decorate; /* * author:Tammy Pi * function:变形金刚的抽象类 */ public abstract class Transformer { public abstract
设计模式学习笔记之简单工厂模式
卧龙居
08-02 833
所谓简单工厂模式，即提供创建对象的接口，而具体创建什么对象，由客户端决定。 比如，我们有IBird这样一个抽象类，有Chicken和Duck这两个类实现IBird。那么，如果我们想灵活的创建Chicken或IBird，那么就需要用到简单工厂模式。 SimpleFactory根据接收到的字符串，决定返回的对象。客户端用父类引用接收子类对象，不需要判别其差别，即可以得到想用的对象。 如下，是这4
设计模式学习笔记之抽象工厂设计模式
卧龙居
08-02 804
抽象工厂，是提供一组接口，而不考虑实现。 比如我们有两个接口，IUser和IClass，负责往数据库里面添加信息。然后有OracleUser和OracleClass，负责往Oracle的数据库中添加信息。然后有SqlserverUser和SqlserverClass，负责往Sql server数据库中添加信息。那么，就需要一个抽象工厂，返回用户所需要的具体对象。 我们用properties来储
设计模式学习笔记之工厂模式
卧龙居
08-10 792
工厂模式是提供了创建了对象的接口，将具体创建什么对象延迟到子类完成。 下面是工厂模式的实例： 有一个操作类的抽象类： package com.DesignPolicyLearn.Factory; /* * author:Tammy Pi * function:操作的抽象类 */ public abstract class Operation { public abst
CVS配置实例
卧龙居
06-21 729
一.关于CVSNT 用的是WIN7的系统，默认CVS的control panel是打不开的，所以CVSNT装好后，需用cmd命令行建立库。 1.cvs -v 可以看到cvs的版本号，那么就证明cvs安装成功。 2.cvs -d d:\MyCvsProject init从而建立了CVS的库 3.CVSNT默认的用户名和密码为系统的用户名和密码 （保证CVS服务启动了） 二.MyEcli
设计模式学习笔记之组合模式
卧龙居
08-01 687
所谓组合模式，即反映部分与整体的关系。使得用户按照同样的方式操作单个对象和对象组合。 举个例子：我们要实现一棵树，那么这棵树就是整体，而树又是又子树构成，子树又由子子树构成。那么树中的两大部分：1.叶子节点 2.子树，即节点的集合。 我们可以知道，对于子树而言，应该有添加功能（增加一个节点），删除功能（删除一个节点），以及显示功能（方便测试）。那么对于叶子节点而言，我们也为它上这三个功能，虽然
设计模式学习笔记之依赖倒转原则
卧龙居
08-07 680
看到依赖倒转，几乎让我猛然想起Spring里的IoC依赖注入。其实两个是不同的概念。 依赖注入，指的是，原来一个类要使用其他类的对象时，需要自己在本类中new一个。而用了Spring之后，只需要在本类中声明一下，然后给个get/set方法，那么实例化的工作就由spring通过扫描applicationContext.xml文件，自己通过反射为其实例化了。由于不需要自己实例化，而是依赖Spring
设计模式学习笔记之原型模式
卧龙居
08-10 654
原型模式提供了确定对象种类的接口，客户端通过拷贝原型来创建重复的对象。 Java中原型模式的实现，即是使用clone方法。 例如我们有一个Cat类： package com.DesignPolicyLearn.Prototype; /* * author:Tammy Pi * function:猫类 */ public class Cat { private Stri
设计模式学习笔记之单一责任模式
卧龙居
08-03 609
一个类，应该只有一个让其变化的原因，也就是说，它的职责应该只有一个。如果一个类，拥有过多的职责，那么就证明代码的耦合性过强。 举个简单的例子：学生在黑板上画圆。画圆的动作应该由圆提供，而不是由黑板提供。如果由黑板提供，那么就违反了单一责任模式了。
observer 设计模式 code c++
最新发布
07-10
下是一个使用观察者（Observer）设计模式的示例代码（C++）： ```cpp #include #include // 观察者接口 class Observer { public: virtual void update(const std::string& message) = 0; }; // 具体观察者A ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值