观察者模式

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

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。

介绍

意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

如何解决：使用面向对象技术，可以将这种依赖关系弱化。

关键代码：在抽象类里有一个 ArrayList 存放观察者们。

应用实例： 1、拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价。 2、西游记里面悟空请求菩萨降服红孩儿，菩萨洒了一地水招来一个老乌龟，这个乌龟就是观察者，他观察菩萨洒水这个动作。

优点：
1、观察者和被观察者是抽象耦合的。
2、建立一套触发机制。

缺点：
1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

场景
一个小baby在睡觉，如果小baby醒了会哭，所以有一个观察者在监听是否睡醒了，小baby在这里就是被观察者，代码如下

class Child{

    private boolean cry =false;

    public boolean isCry(){
        return cry;
    }

    public void wakeUp(){
        System.out.println("wake up！crying wuwuwuwuwu...");
    }
}
public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        while (!child.isCry()){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("observing...");
        }
    }
}

主函数会一直等待，傻等

这时候我在child类中加入一个爸爸的观察者，当baby醒了后调用wakeUp方法，爸爸会喂他

/**
 * @Author huyouting
 * @Date 2021/2/22 10:00
 * @Description:
 */

class Child{

    private boolean cry =false;

    public boolean isCry(){
        return cry;
    }

    public void wakeUp(){
        System.out.println("wake up！crying wuwuwuwuwu...");
    }
}
public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        while (!child.isCry()){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("observing...");
        }
    }
}

如果有多个观察者，比如当baby醒了后，爸爸会喂他，妈妈会抱抱他，狗狗会叫，这时的代码如下：

class Child{

    private boolean cry =false;
    private Dad dad = new Dad();
    private mum mum = new mum();
    private Dog dog = new Dog();
    public boolean isCry(){
        return cry;
    }

    public void wakeUp(){
        cry =true;
        dad.feed();
        mum.hug();
        dog.wang();
    }
}

class Dad{
    public void feed(){
        System.out.println("dad feeding...");
    }
}
class mum{
    public void hug(){
        System.out.println("mum hugging...");
    }
}
class Dog{
    public void wang(){
        System.out.println("Dog wang...");
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        //do sth
        child.wakeUp();
    }
}

问题思考
一个被观察者有很多观察者，每个观察者的处理逻辑不同，比如小狗看到baby醒了会叫，如果看到了一只小鸟也会叫，观察者做出的反应不应该耦合到某一个具体的被观察者身上。如果我再加一个新的观察者，是不是又得在被观察者类中添加新的观察者，这样的耦合度是不是很高？如何解耦？

解决方法：

定义一个观察者接口，所有观察者都得实现这个接口

interface Observer{
    void actionOnWakeUp();
}

actionOnWakeUp()就是小baby醒了后的处理方法，方法并不确定，由具体的实现类去实现。

具体的观察者代码

class Dad implements Observer{

    public void feed(){
        System.out.println("dad feeding...");
    }

    @Override
    public void actionOnWakeUp() {
        feed();
    }
}

class Mum implements Observer{

    public void fug(){
        System.out.println("mum fugging...");
    }

    @Override
    public void actionOnWakeUp() {
        fug();
    }
}

class Dog implements Observer{

    public void wang(){
        System.out.println("dog wanging...");
    }

    @Override
    public void actionOnWakeUp() {
        wang();
    }
}

child类和主函数

class Child{
    private boolean cry =false;
    private List<Observer> observers = new ArrayList<>();
    {
        observers.add(new Dad());
        observers.add(new Mum());
        observers.add(new Dog());
    }

    public boolean isCry(){
        return cry;
    }

    public void wakeUp(){
        cry =true;
        for (Observer observer : observers) {
            observer.actionOnWakeUp();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.wakeUp();
    }
}

很多时候观察者需要根据被观察者的具体情况做出相应的处理，比如说baby哭的时间，地点不同，则观察者做出的反应也不同，所以我们得抽象出一个事件类Event，当baby醒了后得发出这个事件，观察者通过这个事件做出相应的处理。所以重新定义了Observer接口，当baby醒了后，产生了事件的时间为当前时间，地点在床上，并在actionOnWakeUp方法中传递了event（事件）参数，具体代码实现如下：

class Child {
    private boolean cry = false;
    private List<Observer> observers = new ArrayList<>();

    {
        observers.add(new Dad());
        observers.add(new Mum());
        observers.add(new Dog());
    }

    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;

        wakeUpEvent event = new wakeUpEvent(System.currentTimeMillis(),"bed");

        for (Observer observer : observers) {
            observer.actionOnWakeUp(event);
        }
    }
}

//事件类 fireEvent
class wakeUpEvent {
    long timestamp;
    String loc;

    public wakeUpEvent(long timestamp, String loc) {
        this.timestamp = timestamp;
        this.loc = loc;
    }
}

interface Observer {
    void actionOnWakeUp(wakeUpEvent event);
}

class Dad implements Observer {

    public void feed() {
        System.out.println("dad feeding...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        feed();
    }
}

class Mum implements Observer {

    public void fug() {
        System.out.println("mum fugging...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        fug();
    }
}

class Dog implements Observer {

    public void wang() {
        System.out.println("dog wanging...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        wang();
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.wakeUp();
    }
}

在这里插入图片描述
大多数时候，我们处理事件的时候，需要事件源对象，因为观察者做出的反应可能是根据不同事件源做出反应的，比如小狗不只是当baby醒了后会叫，当看见一只小猫或者小鸡的时候也会叫，所以当处理具体的逻辑时需要知道是哪个事件源发出的，观察者的动作和事件源本身并不是完完全全耦合的，不同的事件源可能有同一个观察者，一个事件源也可能有多个观察者，事件源也可以发出好多个不同的事件。所以，事件源和事件和观察者的耦合度没那么高。具体代码实现如下：

/**
 * @Author huyouting
 * @Date 2021/2/22 10:17
 * @Description:
 */

/**
 * 有很多时候，观察者需要根据事件的具体情况来进行处理
 * 大多数时候，我们处理事件的时候，需要事件源对象
 */
class Child {
    private boolean cry = false;
    private List<Observer> observers = new ArrayList<>();

    {
        observers.add(new Dad());
        observers.add(new Mum());
        observers.add(new Dog());
    }

    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;

        wakeUpEvent event = new wakeUpEvent(System.currentTimeMillis(), "bed",this);

        for (Observer observer : observers) {
            observer.actionOnWakeUp(event);
        }
    }
}

//事件类 fireEvent
class wakeUpEvent {
    long timestamp;
    String loc;
    Child source;

    public wakeUpEvent(long timestamp, String loc,Child source) {
        this.timestamp = timestamp;
        this.loc = loc;
        this.source=source;
    }
}

interface Observer {
    void actionOnWakeUp(wakeUpEvent event);
}

class Dad implements Observer {

    public void feed() {
        System.out.println("dad feeding...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        feed();
    }
}

class Mum implements Observer {

    public void fug() {
        System.out.println("mum fugging...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        fug();
    }
}

class Dog implements Observer {

    public void wang() {
        System.out.println("dog wanging...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        wang();
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.wakeUp();
    }
}

事件也可以形成继承体系，定义一个Event事件的父类，所有Event子类继承

class Child {
    private boolean cry = false;
    private List<Observer> observers = new ArrayList<>();

    {
        observers.add(new Dad());
        observers.add(new Mum());
        observers.add(new Dog());
        observers.add((e)->{
            System.out.println("ppp");
        });
        //hook callback
    }

    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;

        wakeUpEvent event = new wakeUpEvent(System.currentTimeMillis(), "bed",this);

        for (Observer observer : observers) {
            observer.actionOnWakeUp(event);
        }
    }
}

abstract class Event<T>{
    abstract T getSource();
}

//事件类 fireEvent
class wakeUpEvent extends Event<Child> {
    long timestamp;
    String loc;
    Child source;

    public wakeUpEvent(long timestamp, String loc,Child source) {
        this.timestamp = timestamp;
        this.loc = loc;
        this.source=source;
    }

    @Override
    Child getSource() {
        return source;
    }
}

interface Observer {
    void actionOnWakeUp(wakeUpEvent event);
}

class Dad implements Observer {

    public void feed() {
        System.out.println("dad feeding...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        feed();
    }
}

class Mum implements Observer {

    public void fug() {
        System.out.println("mum fugging...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        fug();
    }
}

class Dog implements Observer {

    public void wang() {
        System.out.println("dog wanging...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        wang();
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.wakeUp();
    }
}
叫我坏蛋就好
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
设计模式学习笔记 --- 20.观察者模式
杨鑫newlife的专栏
04-27 281
当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖关系。观察者模式属于行为模式； 意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新； 主要解决：一个对象状态改变给其他对象通知到问题，而且要考虑到易用和低耦合，保证高度的协作； 何时...
【设计模式】——11种行为型模式
十二翼堕落天使
12-14 686
行为型模式用于 - 描述程序在运行时复杂的流程控制 - 描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务 - 分配算法与对象间的职责
行为型模式之观察者模式
qq_30357519的博客
04-29 190
行为型模式之观察者模式模式结构和说明示例代码iOS中的观察者模式模式讲解1. 目标和观察者之间的关系2. 单向依赖3.基本的实现说明模式本质 当对象间存在一对多关系时,则使用观察者模式(Observer Pattern),比如,当一个对象呗修改时,则会自动通知它的依赖对象,观察者模式属于行为型模式 一个经典的例子就是订阅报纸.你不用去任何地方,只需要将你的个人地址信息以及订阅信息告诉出版社,出...
游戏编程模式——观察者模式（Observer）
m0_62210253的博客
03-18 563
观察者模式（Observer Pattern）是应用最广泛的GoF模式，本文将介绍一些观察者模式在游戏中的应用。
观察者模式1
08-08
观察者模式，是一种广泛应用在软件设计中的对象行为型模式，其核心思想是让一个对象能够在其状态发生变化时，自动通知所有对其感兴趣的其他对象。这种模式促进了"发布-订阅"概念的实现，允许对象间的解耦，提高代码...
C++实现观察者模式
01-20
要通知到需要了解该变化的类，Windows编程中经常用到的是发消息，要是没有Windows的消息机制的话，自己做一套消息机制倒是可以，但也是徒增了工作量，再次想到了设计模式中的观察者模式，也可以实现这个想法，具体...
iOS 设计模式 观察者模式
02-18
观察者模式，也被称为发布-订阅（Publish-Subscribe）模式，是软件设计中的一种行为模式。在iOS开发中，它是一种让多个对象监听或订阅某一个主题对象的状态变化，并在状态变化时自动收到通知的方式。这种模式使得...
游戏设计模式-观察者模式
qq_38815038的博客
04-09 5311
成就系统，基本上是每个游戏里都会涉及到的系统，但如果直接使用其它系统的函数接口，你将会发现整个项目中，每个系统都要和成就系统耦合在一起。 这是一件极其糟糕的事情。 观察者模式可以解决这件事情。 首先，我们先定义两个类，分别是观察者和被观察者。 观察者： class Observer { friend class Subject; public: Observer() :next(nullptr), previous(nullptr) {} void OnNotify(con.
多目标优化
kudouranaaa的博客
12-08 2万+
多目标进化算法求解方式，介绍传统以及进化算法，以及NSGA-Ⅱ实例
多目标优化蚁群算法的matlab_深入浅出多目标优化10分钟多目标优化入门
weixin_39956558的博客
11-21 2726
多目标优化快速入门多目标优化--引子正如生活中，你想买一辆车，又想汽车的性能好，外观不错，价格还比较低，对于这同时满足这三个条件，我们应该如何进行考虑呢？在投资的时候，我们想投入的资金最少，所付出的风险最小，同时收益是最大的，如何同时进行实现呢？在数学学习中，求求函数 f1(x1,x2,…,xn)=x1^2+x2^2 +…+xn^2 及函数 f2(x1,x2,…,xn)=(x1-1)^2...
五种多目标优化算法（MOFA、NSWOA、MOJS、MOAHA、MOPSO）性能对比（提供MATLAB代码）
最新发布
IT猿手
02-25 4489
多目标优化算法是用于解决具有多个目标函数的优化问题的一类算法。其求解流程通常包括以下几个步骤：1. 定义问题：首先需要明确问题的目标函数和约束条件。多目标优化问题通常涉及多个目标函数，这些目标函数可能存在冲突，需要在不同目标之间进行权衡。2. 生成初始解集：通过随机生成或者其他混沌映射生成一组初始解集。这些初始解集通常是在可行解空间内随机分布的。3. 评估解集：对初始解集中的每个解进行评估，计算其在各个目标函数上的值。这些值可以用来衡量解的优劣程度。
多目标优化问题MOP
a999999123的博客
11-22 1万+
概念 多目标优化问题( multi-objective optimization problem，MOP)也称为向量优化问题或多准则优化问题。多目标优化问题可以描述为:在可行域中确定由决策变量组成的向量，它满足所有约束，并且使得由多个目标函数组成的向量最优化。 而这些组成向量的多个目标函数彼此之间通常都是互相矛盾的。 因此，这里的“优化”意味求一个或一组解向量使目标向量中的所有目标函数满足设计者的要求。 这些相互冲突的子目标，一个子目标的改善有可能会引起另一个或者另几个子目标的性能降低 , 也就是要同时使多
多目标优化的意义、方法、研究难点和热点
fengdu78的博客
01-23 6665
本期目录：一、多目标优化的意义到底是什么？二、多目标优化详解三、目前关于多目标优化的研究难点和热点有哪些？多目标优化的意义到底是什么？定义如下多目标优化问题，3单目标加权求和只能逼近凸的帕累托面加权求和的方式只能逼近帕累托前沿面为凸集的情况，如果多目标优化问题的帕累托面为非凸，则加权求和的方式就不能和原多目标优化问题等价，此时只有直接处理原多目标优化问题才能解决。4多目标优化问题的帕累托解集包...
多目标优化详解【转载】
热门推荐
徐奕的专栏
09-02 4万+
欢迎大家访问我的网站发现更多内容omegaxyz.com 多目标优化问题详解 生活中 ,许多问题都是由相互冲突和影响的多个目标组成。人们会经常遇到使多个目标在给定区域同时尽可能最佳的优化问题 ,也就是多目标优化问题。优化问题存在的优化目标超过一个并需要同时处理 ,就成为多目标优化问题。 多目标优化问题在工程应用等现实生活中非常普遍并且处于非常重要的地位 ,这些实
设计模式应用：深入观察者模式
在.NET框架中，观察者模式常用于建立对象之间的依赖关系，使得当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这个模式的核心思想是定义一个接口，让感兴趣的观察者可以注册到被观察的对象...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值