java设计模式-Observe

最新推荐文章于 2022-12-12 21:41:55 发布
最新推荐文章于 2022-12-12 21:41:55 发布
阅读量103 收藏
点赞数
文章标签： java 设计模式
原文链接：http://www.cnblogs.com/tenWood/p/9206107.html
版权

一、背景　　　　　　　　　　　　　　　　　　　　

请模拟下面情形：
小孩在睡觉，醒来后要求吃东西
 
代码： 
class Child{
    private boolean wakenUp = false;
    
    void wakeUp(){
        wakenUp = true;
    }

    public boolean isWakenUp() {
        return wakenUp;
    }
    public void setWakenUp(boolean wakenUp) {
        this.wakenUp = wakenUp;
    }
}

class Dad implements Runnable{
    Child c;
    
    public Dad(Child c){
        this.c = c;
    }
    
    @Override
    public void run() {
        while(!c.isWakenUp()){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        feed(c);
    }

    private void feed(Child c) {
        System.out.println("feed child");
    }
    
}


public class Test {

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

}

上面代码运行起来是有问题的，永远等在那里，因为child永远不会醒过来；

那么，想让小孩5s之后醒过来怎么做？

 

二、让小孩5s之后醒　　　　　　　　　　

每一个小孩就是一个单独的线程；
 
代码： 
class Child implements Runnable{
    private boolean wakenUp = false;
    
    void wakeUp(){
        wakenUp = true;
    }

    public boolean isWakenUp() {
        return wakenUp;
    }
    public void setWakenUp(boolean wakenUp) {
        this.wakenUp = wakenUp;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.wakeUp();
    }
}

class Dad implements Runnable{
    Child c;
    
    public Dad(Child c){
        this.c = c;
    }
    
    @Override
    public void run() {
        while(!c.isWakenUp()){
            System.out.println("child is't wake up");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        feed(c);
    }

    private void feed(Child c) {
        System.out.println("feed child");
    }
    
}


public class Test {

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

}

console：

child is't wake up
child is't wake up
child is't wake up
child is't wake up
child is't wake up
feed child

 

这个小程序就模拟完了；也就是说要做完这个功能就已经做完了；
但是有什么不合理的地方？
小孩一直在睡着，如果采取现在这种编程模式，Dad就一直监视，无法干其他事情了，就只能在这里死死的盯着他；1s钟盯一眼，太累了；
这个累的意思就是， CPU的资源无端的被消耗了，CPU没事老是在这循环着；如果小孩3小时不醒就得循环3小时；这种编程的方式起码在效率上有问题；
 
那么，怎么修正这个问题呢？
 
 
 
三、第二版的设计　　　　　　　　　　　　　　
第二版的设计，不要让Dad在这浪费时间了；
Dad是主动的检测这个小孩有没有醒；主动的监听是非常消耗CPU资源的；
让小孩醒过来的时候自己调我这方法就完了；反过来让小孩监控他Dad；
 
代码: 
class Child implements Runnable{
    private Dad d;
    
    public Child(Dad d){
        this.d = d;
    }
    
    void wakeUp(){
        d.feed(this);
    }

    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.wakeUp();
    }
}

class Dad{
    public void feed(Child c) {
        System.out.println("feed child");
    }
}


public class Test {

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

}

过5s后，console打印：feed child

 

同样的功能，这种方式比上面的要效率高一些，消耗的CPU要少一些；
但是作为设计来讲，在一个软件项目之中的设计，如果只考虑到当前这种设计不具有弹性，也就是 不具有可扩展性；
什么叫做没有弹性？
比方说设计一个新闻系统，发表一篇文章需要经过三级审查，编辑审了，副主编审，再主编审；如果不符合要求或者含有反动等信息就不能发表出去；
这时候你在程序里就写了三级，假如说将来级别增加了，需要四级审查、五级...怎么办？改源代码就很累；
考虑到可扩展性就可以用一个参数做配置，在配置文件里写3就是三级审查，写4就是四级审查....这样就有弹性一些；
 
上面代码，考虑一个问题：小孩可能会在不同的时间段醒来、不同的地点醒来，针对于不同醒来的事件，Dad的处理方式应该是不同的；这件事情的发生是包含着一些具体情况的，应该把不同的情况告诉他Dad，怎么样把事情的各种各样的信息告诉他Dad呢？
该用什么样的设计方法？
 
 
 
四、对于事件的处理　　　　　　　　　　　　
对于Dad来说，要根据事件的具体情况，才能做出具体的选择，也就是说作为Child来说，有责任把这件事情的具体情况通知你的监测人；
可以这么写，在Child里面增加什么时候醒来的时间time、醒来的地点loc，然后传给feed()里面的child c；
 
 可以这么写： 
class Child implements Runnable{
    private Dad d;
    String time;
    String loc;
    
    public Child(Dad d){
        this.d = d;
    }
    
    void wakeUp(){
        time = "晚上";
        loc = "床上";
        d.feed(this);
    }

    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.wakeUp();
    }
}

class Dad{
    public void feed(Child c) {
        System.out.println("child wake up time :" + c.time);
        System.out.println("child wake up location :" + c.loc);
        System.out.println("feed child");
    }
}


public class Test {

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

console：5s后打印：

child wake up time :晚上
child wake up location :床上
feed child

 

但是： 仔细分析，作为time它应该是小孩的属性吗？loc应该是小孩的属性吗？
不是，它们应该是事件本身的属性；是事件发生时候的时间、地点。
所以，面向对象设计的一条最基础的原则： 最合适的属性应该放在最合适的类里面；
 
所以：
1）再增加一个事件类：
2）并且，child的wakeUp()方法里面调用Dad的feed()方法，已经写死了，假如child醒过来不想让Dad喂他，而是让Dad带他出去玩呢？
那么feed方法就不合适了。更灵活的方法是：child一醒过来发出一件事，就让Dad对这件事做出反应，只要Dad做出正确的反应就ok了。
所以feed方法换为ActionToWakenUp;

 

代码：

/**
 * 醒过来的事件
 */
class WakenUpEvent{
    private long time;
    private String loc;
    private Child source;        //发生事件的源对象
    
    public WakenUpEvent(long time, String loc, Child source) {
        super();
        this.time = time;
        this.loc = loc;
        this.source = source;
    }
    public long getTime() {
        return time;
    }
    public void setTime(long time) {
        this.time = time;
    }
    public String getLoc() {
        return loc;
    }
    public void setLoc(String loc) {
        this.loc = loc;
    }
    public Child getSource() {
        return source;
    }
    public void setSource(Child source) {
        this.source = source;
    }
}

class Child implements Runnable{
    private Dad d;

    public Child(Dad d){
        this.d = d;
    }
    
    void wakeUp(){
        d.ActionToWakenUp(new WakenUpEvent(System.currentTimeMillis(), "bed", this));
    }

    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.wakeUp();
    }
}

class Dad{
    public void ActionToWakenUp(WakenUpEvent e) {
        System.out.println("child wake up time " + e.getTime());
        System.out.println("child wake up location " + e.getLoc());
        System.out.println("feed child");
    }
}

public class Test {

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

console，5s后打印：

child wake up time 1529505152384
child wake up location bed
feed child

 

 

上面的设计其实还有问题：

假如说不止Dad，小孩醒过来爷爷也要做出一点反应，该怎么办呢？怎么样让更多的人对这件事做出反应？

 

 

 五、第三种设计方法　　　　　　　　　　

现在问题是怎么让监听事件的这些个人Dad、GrandFather、奶奶，以及对事件做出响应，怎么能做到比较好的扩展，不需要在Child类里面改来改去；
因为在Child里面改的话：
不但要增加private GrandFather gf;
还需要在wakeUp方法里面增加GrandFather的ActionToWakenUp方法；
还需要修改Child的构造方法，Child(Dad d, GrandFather gf)
...
 
修改为如下： 
import java.util.ArrayList;
import java.util.List;



public class Test {
    public static void main(String[] args) {
        Child c = new Child();
        c.addWakenUpListener(new Dad());
        c.addWakenUpListener(new GrandFather());
        new Thread(c).start();
    }
}

/**
 * 发出事件的主体
 */
class Child implements Runnable{
    private List<WakenUpListener> WakenUplisteners = new ArrayList<WakenUpListener>();

    public void addWakenUpListener(WakenUpListener l){
        this.WakenUplisteners.add(l);
    }

    void wakeUp(){
        for(WakenUpListener listener : WakenUplisteners){
            listener.ActionToWakenUp(new WakenUpEvent(System.currentTimeMillis(), "bed", this));
        }
    }
    
    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.wakeUp();
    }
}

//对应醒事件的监听器接口
interface WakenUpListener {
    public void ActionToWakenUp(WakenUpEvent e);
}

//Dad监听器
class Dad implements WakenUpListener{
    public void ActionToWakenUp(WakenUpEvent e) {
        System.out.println("event time: "+e.getTime() +",event location: "+e.getLoc());
        System.out.println("feed child");
    }
}
//GrandFather监听器
class GrandFather implements WakenUpListener{
    public void ActionToWakenUp(WakenUpEvent e) {
        System.out.println("event time: "+e.getTime() +",event location: "+e.getLoc());
        System.out.println("hug child");
    }
}

/**
 * 醒事件
 */
class WakenUpEvent{
    private long time;
    private String loc;
    private Object source;        //发生事件的源对象
    
    public WakenUpEvent(long time, String loc, Object source) {
        super();
        this.time = time;
        this.loc = loc;
        this.source = source;
    }
    public long getTime() {
        return time;
    }
    public void setTime(long time) {
        this.time = time;
    }
    public String getLoc() {
        return loc;
    }
    public void setLoc(String loc) {
        this.loc = loc;
    }
    public Object getSource() {
        return source;
    }
    public void setSource(Object source) {
        this.source = source;
    }
}

console：

event time: 1529508249412,event location: bed
feed child
event time: 1529508249413,event location: bed
hug child

 

 

转载于:https://www.cnblogs.com/tenWood/p/9206107.html

weixin_34008933
关注
观察者模式---Java记录
BXA
02-25 319
前言 　　　观察者的学习又是一次新的收获，对于设计模式越发好奇，能够更多的体会到，这些设计方式是前辈们不断尝试思考得出 的宝贵方法，针对特定的抽象的问题制定出目前可靠性维护性极佳的一种编程方式。 观察者解决的问题 　　　那么从解决问题的角度来看，观察者可以帮我们搞定什么样的问题呢？ 信息交互 　　　实际应用举例：关注的微信公众号 ； 订阅的邮件 等。 解决方式 　　　...
java 观察者模式 (Observe)
11-12
java-观察者模式(Observe)
JAVA设计模式-Observer
02-24 2312
Java提供了Observer模式的默认实现，下面我们就看一下Java对观察者模式的支持。 Java对观察者模式的支持主要体现在Observable类和Observer接口。
Java 中的 Observer
边走边唱
06-19 206
  Java 中的 Observer ： Java 提供了 Observer 模式的默认实现，下面我们就看一下 Java 对 观察者模式的支持。 Java 对 观察者模式的支持 主要体现在 Observable  类和 Observer 接口。 (1) Observable  类代表 被观察者 （java.util.Observable ...
java中的Observer模式
Willis Yang
10-26 187
        java语言里包含了许多对设计模式的直接支持，如command模式，agent模式，observer模式等。虽然java提供的对这些模式的支持很简单，不能满足比较复杂的应用。但在简单的场景下，使用这些类往往能够得到立杆见影的效果。所以，如果没有什么特殊需求，还是最好利用java的这些类。         Observer模式，又称监听模式，观察者模式，是经典设计模式之一（one o...
Java设计模式之观察者模式(Observer Pattern)
王鸿飞的专栏
06-18 4335
Observer Pattern 是一种常用的设计模式，它是一种事件监听模型，
android-observe
04-01
消费者模式，也称为生产者-消费者模式，是设计模式中的一种，用于处理并发问题，通过分离数据的生产和消费，使得两者可以独立进行，避免了因同步问题引发的阻塞。在Android应用中，这种模式可以提高代码的可维护性和...
Java设计模式
weixin_48304192的博客
06-19 1047
设计模式
java-coap,coap java库.zip
10-11
7. **事件驱动编程**：Java-CoAP库基于观察者模式设计，使得开发人员可以注册回调函数来处理请求、响应和其他事件，提高代码的可读性和可维护性。 8. **易于集成**：由于是用Java编写的，Java-CoAP库可以无缝集成到...
设计模式(JAVA)——Observer模式
读书 好学 求知
11-27 558
设计模式java之Observer模式，观察者模式。发布-订阅
ObservePattern--观察者模式java实现
weixin_33901641的博客
12-19 124
2019独角兽企业重金招聘Python工程师标准>>> ...
Java Observer(观察者模式)
Moonlightes的博客
03-16 510
实现观察者模式 [1]创建被观察者类，它继承自java.util.Observable类； [2]创建观察者类，它实现java.util.Observer接口； //被观察者 class SimpleObservable extends Observable { public void setData(int i) { i = i + 1; setChanged(
【设计模式】观察者模式Observe（Java）
最新发布
鹏啊鹏
12-12 1417
观察者模式定义了对象之间的一对多依赖，这样以来，当一个对象改变状态时，他的所有观察者都会收到通知并且自动更新。
java observer_Java观察者模式(Observer)
weixin_31966615的博客
02-12 559
一、定义观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，让他们能够自动更新自己。主要应用在java的AWT事件机制。二、角色抽象主题角色(Subject)：把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类或接口来实现...
observer java_观察者模式-Observer(Java实现)
weixin_39851307的博客
02-20 112
观察者模式-Observer当一个对象变化时,其它依赖该对象的对象都会收到通知, 并且会随着变化!对象之间是一种一对多的关系。换一种表达方式: 有很多观察者们依赖于(观察)同一个对象(主题), 当这个被依赖的对象(主题)变化时, 观察者们也会随之变化.本文中的例子如下: 有一个进度生成器, 用来模拟进度条的数值. 当进度数值更新后, 就会通知进度栏更新值. 也就是进度栏是观察者, 随时间在变的进度...
Java 语言使用 Observer/Observable 实现简单的观察者模式
互联网那些事
11-20 222
观察者模式的简单概念 假设现在有A、B、C、D等四个独立的对象，其中B、C、D这三个对象想在A对象发生改变的第壹时间知道这种改变，以便做出相应的响应。 上面的这种情形，就是观察者模式。当然每個被观察者可以有多个观察者，每個观察者也可以有多个被观察者。观察者与被观察者也不是对立的，壹個对象可以观察其他对象，也可以被其他对象观察。 观察者模式的应用场景 为了更好的理解什么是观察者模式，...
Java 设计模式之 Observer 模式
风香枫
07-22 354
这种模式抽象出三个角色，被观察者，观察者，事件。 观察者：将观察者抽象为interface接口，将观察者的行为抽象为一个个方法，具体观察者通过实现观察者接口，并实现这些方法，来赋予具体的行为。 被观察者：发出某些事件，将事件通知给观察者。 事件：事件里将被观察者作为成员对象，这样需要对原对象进行处理，或者使用原对象的方法时，可以从事件里获得事件原对象。 被观察者发出某事件，通知观察者，观察者根据事件作出响应。 举个咖啡馆Cafe的例子，客户进来，要点餐，要结账，服务员会拿过来菜单，账单。 观察者
浅谈Observer在Java中的实现
gavin46的专栏
01-08 1211
写在前面... 1简单玩具... 1[ 实现一 ]：... 1基本规范... 2[ 实现二 ] :. 3高级功能... 4[ 实现三 ] :. 6其他 – UI线程中的Observer. 8参考资料... 8 写在前面Observer（发布订阅机制）是MVC架构的基石，是非常普遍的行为型设计模式之一。本文简单讨论了Observer设计模式在不同层次上
Java设计模式（八）之观察者模式（Observer）
L
05-24 378
本文以JDK源码介绍。 观察者Observer public interface Observer { void update(Observable o, Object arg); } 被观察者Observable public class Observable { private boolean changed = false; private Vector<Observer> obs; public Observable() {...
Python库azcam-observe的21.2.1版本发布
资源摘要信息:"Python库 | azcam-observe-21.2.1.tar.gz" 知识点： 1. Python库的概念：Python库是一组预先编写的代码模块，这些代码被设计为方便程序员在进行项目开发时进行复用。库通常包含了一些特定的功能，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值