JAVA-设计模式：AKA观察者模式（行为型）

最新推荐文章于 2022-05-31 15:15:23 发布
最新推荐文章于 2022-05-31 15:15:23 发布
阅读量193 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46524005/article/details/107915112
版权

观察者模式（Observer Pattern）：观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。

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

推拉两种获取数据方式：

  • 推：可以把数据当做数据对象的方式传给观察者
  • 拉：通过getter方法获取数据

关键代码：在抽象类里有一个 ArrayList 存放观察者们。（如果使用JAVA 中已经有了对观察者模式的支持类则不需要

Observer和Observable）

松耦合的威力：

  • 两个对象之间松耦合，他们可以交互，但是不太清楚彼此的细节
  • 观察者模式提供了一种对象设计，让主题和观察者之间松耦合
  • 主题只知道观察者对象实现了某个接口，而不知道观察者具体的细节
  • 我们可以随时添加和删除观察者

适用性

  1. 当一个抽象模型有两个方面，其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
  2. 当对一个对象的改变需要同时改变其它对象， 而不知道具体有多少对象有待改变。
  3. 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之，你不希望这些对象是紧密耦合的。

角色：

1.主题接口、实现

2.观察者接口、实现

要点

  1. 观察者模式定义了对象之间一对多的关系。
  2. 主题（也就是可观察者）用一个共同的接口来更新观察者。
  3. 观察者和可观察者之间用松耦合方式结合，可观察者不知道观察者的细节，只知道观察者实现了观察者接口。
  4. 使用此模式时，你可从被观察者处推或拉数据。
  5. 有多个观察者时，不可以依赖特定的通知次序。
  6. Java有多种观察者模式的实现，包括了通用的java.util.Observable。
  7. 要注意java.util.Observable实现上所带来的一些问题。Swing大量使用观察者模式，许多GUI框架也是如此。
    1. Java内置的观察者模式中Observable是一个类，你必须设计一个类去继承它。如果某类相同时具有Observable类和另一个超类的行为，就无法实现，因为java不支持多继承。
    2. Observable API将setChanged()方法保护了起来，除非继承自Observable类，否则无法创建Observable实例组合到自己的对象中，也违背了面向对象设计的第二个原则：多用组合，少用继承。
  8. 此模式也被应用在许多地方，例如：JavaBeans、RMI。

 

举例：实现一个气象监测系统，此系统的三个部分是气象站（获取实际气象数据的物理装置）、WeatherData对象（追踪来自气象站的数据，并更新布告板）和布告板（显示目前天气状况给用户看）（每个布告板根据相同数据展示的内容不同）

方式一：自己定义观察者接口

//主题接口
public interface Subject {
    public void registerObserver(Observer o);

    public void removeObserver(Observer o);

    public void notifyObservers();
}

//主题实现类
public class WeatherData implements Subject {
    private ArrayList<Observer> observers;
    private float temperature;
    private float humidity;
    private float pressure;

    public WeatherData() {
        observers = new ArrayList<Observer>();
    }

    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        int i = observers.indexOf(o);
        if (i >= 0) {
            observers.remove(i);
        }
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }

    public void measurementsChanged(){
        notifyObservers();
    }

    public void setMeasurements(float temperature, float humidity, float pressure){
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }

    public float getTemperature() {
        return temperature;
    }

    public float getHumidity() {
        return humidity;
    }

    public float getPressure() {
        return pressure;
    }
}

//观察者接口
public interface Observer {
    public void update(float temp, float humidity, float pressure);
}

//观察者共同行为接口
public interface DisplayElement {
    public void display();
}

//观察者实现类
public class CurrentConditionsDisplay implements Observer, DisplayElement {
    private float temperature;
    private float humidity;
    private Subject weatherData;

    public CurrentConditionsDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    @Override
    public void update(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        display();
    }

    @Override
    public void display() {
        System.out.println("Current conditions: " + temperature
                + "F degrees and " + humidity + "% humidity");
    }
}

public class ForecastDisplay implements Observer, DisplayElement {
    private float currentPressure = 29.92f;
    private float lastPressure;
    private Subject weatherData;

    public ForecastDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    @Override
    public void update(float temp, float humidity, float pressure) {
        lastPressure = currentPressure;
        currentPressure = pressure;

        display();
    }

    @Override
    public void display() {
        System.out.print("Forecast: ");
        if (currentPressure > lastPressure) {
            System.out.println("Improving weather on the way!");
        } else if (currentPressure == lastPressure) {
            System.out.println("More of the same");
        } else if (currentPressure < lastPressure) {
            System.out.println("Watch out for cooler, rainy weather");
        }
    }
}

public class StatisticsDisplay implements Observer, DisplayElement {
    private float maxTemp = 0.0f;
    private float minTemp = 200;
    private float tempSum = 0.0f;
    private int numReadings;
    private Subject weatherData;

    public StatisticsDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    @Override
    public void update(float temp, float humidity, float pressure) {
        tempSum += temp;
        numReadings++;

        if (temp > maxTemp) {
            maxTemp = temp;
        }

        if (temp < minTemp) {
            minTemp = temp;
        }

        display();
    }

    @Override
    public void display() {
        System.out.println("Avg/Max/Min temperature = " + (tempSum / numReadings)
                + "/" + maxTemp + "/" + minTemp);
    }
}

public class HeatIndexDisplay implements Observer, DisplayElement {
    private float heatIndex = 0.0f;
    private Subject weatherData;

    public HeatIndexDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    @Override
    public void update(float temp, float humidity, float pressure) {
        heatIndex = computeHeatIndex(temp, humidity);
        display();
    }

    private float computeHeatIndex(float t, float rh) {
        float index = (float) ((16.923 + (0.185212 * t) + (5.37941 * rh) - (0.100254 * t * rh)
                + (0.00941695 * (t * t)) + (0.00728898 * (rh * rh))
                + (0.000345372 * (t * t * rh)) - (0.000814971 * (t * rh * rh)) +
                (0.0000102102 * (t * t * rh * rh)) - (0.000038646 * (t * t * t)) + (0.0000291583 *
                (rh * rh * rh)) + (0.00000142721 * (t * t * t * rh)) +
                (0.000000197483 * (t * rh * rh * rh)) - (0.0000000218429 * (t * t * t * rh * rh)) +
                0.000000000843296 * (t * t * rh * rh * rh)) -
                (0.0000000000481975 * (t * t * t * rh * rh * rh)));
        return index;
    }

    @Override
    public void display() {
        System.out.println("Heat index is " + heatIndex);
    }
}

//测试类
public class WeatherStationHeatIndex {
    public static void main(String[] args){
        WeatherData weatherData = new WeatherData();
        CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);
        StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
        ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);
        HeatIndexDisplay heatIndexDisplay = new HeatIndexDisplay(weatherData);

        weatherData.setMeasurements(80, 65, 30.4f);
        weatherData.setMeasurements(82, 70, 29.2f);
        weatherData.setMeasurements(78, 90, 29.2f);
    }
}

方式二：使用JAVA已有观察者模式支持接口及类（有弊端）

提供““拉”的数据获取方式：通过getter方法获取数据

使用JAVA 中已经有了对观察者模式的支持类及接口：Observer（代替观察者接口）和Observable（代替主题接口，主题类不用list）

 

//主题类
public class WeatherData extends Observable {
    private float temperature;
    private float humidity;
    private float pressure;

    public WeatherData() {

    }

    public void measurementsChanged(){
        setChanged();
        notifyObservers();
    }

    public void setMeasurements(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }

    public float getTemperature() {
        return temperature;
    }

    public float getHumidity() {
        return humidity;
    }

    public float getPressure() {
        return pressure;
    }
}

//观察者共同行为接口
public interface DisplayElement {
    public void display();
}

//观察者实现类
public class CurrentConditionsDisplay implements Observer, DisplayElement {
    private Observable observable;
    private float temperature;
    private float humidity;

    public CurrentConditionsDisplay(Observable observable) {
        this.observable = observable;
        observable.addObserver(this);
    }

    @Override
    public void display() {
        System.out.println("Current conditions: " + temperature
                + "F degrees and " + humidity + "% humidity");
    }

    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof WeatherData) {
            WeatherData weatherData = (WeatherData) o;
            this.temperature = weatherData.getTemperature();
            this.humidity = weatherData.getHumidity();
            display();
        }
    }
}

public class ForecastDisplay implements Observer, DisplayElement {
    private float currentPressure = 29.92f;
    private float lastPressure;

    public ForecastDisplay(Observable observable) {
        observable.addObserver(this);
    }

    @Override
    public void display() {
        System.out.print("Forecast: ");
        if(currentPressure > lastPressure){
            System.out.println("Improving weather on the way!");
        }else if(currentPressure == lastPressure){
            System.out.println("More of the same");
        }else{
            System.out.println("Watch out for cooler, rainy weather");
        }
    }

    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof WeatherData) {
            WeatherData weatherData = (WeatherData) o;
            lastPressure = currentPressure;
            currentPressure = weatherData.getPressure();
            display();
        }
    }
}

public class StatisticsDisplay implements Observer, DisplayElement {
    private float maxTemp = 0.0f;
    private float minTemp = 200;
    private float tempSum= 0.0f;
    private int numReadings;

    public StatisticsDisplay(Observable observable) {
        observable.addObserver(this);
    }

    public void update(Observable observable, Object arg) {
        if (observable instanceof WeatherData) {
            WeatherData weatherData = (WeatherData)observable;
            float temp = weatherData.getTemperature();
            tempSum += temp;
            numReadings++;

            if (temp > maxTemp) {
                maxTemp = temp;
            }

            if (temp < minTemp) {
                minTemp = temp;
            }

            display();
        }
    }

    public void display() {
        System.out.println("Avg/Max/Min temperature = " + (tempSum / numReadings)
                + "/" + maxTemp + "/" + minTemp);
    }
}

public class HeatIndexDisplay implements Observer, DisplayElement {
    float heatIndex = 0.0f;

    public HeatIndexDisplay(Observable observable) {
        observable.addObserver(this);
    }

    public void update(Observable observable, Object arg) {
        if (observable instanceof WeatherData) {
            WeatherData weatherData = (WeatherData)observable;
            float t = weatherData.getTemperature();
            float rh = weatherData.getHumidity();
            heatIndex = (float)
                    (
                            (16.923 + (0.185212 * t)) +
                                    (5.37941 * rh) -
                                    (0.100254 * t * rh) +
                                    (0.00941695 * (t * t)) +
                                    (0.00728898 * (rh * rh)) +
                                    (0.000345372 * (t * t * rh)) -
                                    (0.000814971 * (t * rh * rh)) +
                                    (0.0000102102 * (t * t * rh * rh)) -
                                    (0.000038646 * (t * t * t)) +
                                    (0.0000291583 * (rh * rh * rh)) +
                                    (0.00000142721 * (t * t * t * rh)) +
                                    (0.000000197483 * (t * rh * rh * rh)) -
                                    (0.0000000218429 * (t * t * t * rh * rh)) +
                                    (0.000000000843296 * (t * t * rh * rh * rh)) -
                                    (0.0000000000481975 * (t * t * t * rh * rh * rh)));
            display();
        }
    }

    public void display() {
        System.out.println("Heat index is " + heatIndex);
    }
}

//测试类
public class WeatherStationHeatIndex {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        CurrentConditionsDisplay currentConditions = new CurrentConditionsDisplay(weatherData);
        StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
        ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);
        HeatIndexDisplay heatIndexDisplay = new HeatIndexDisplay(weatherData);

        weatherData.setMeasurements(80, 65, 30.4f);
        weatherData.setMeasurements(82, 70, 29.2f);
        weatherData.setMeasurements(78, 90, 29.2f);
    }
}
L'E'tranger
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
coroutines,协同并发的纯Java实现，AKA协同程序.zip
09-24
coroutines,协同并发的纯Java实现，AKA协同程序.zip
JAVA-设计模式：AKA原型模式（创建型）
weixin_46524005的博客
08-05 326
用途：在一个复杂的类层次中，当系统必须从其中的许多类型创建新对象时，可以考虑原型。 优点： 1.向客户隐藏制造新实例的复杂性。 2.提供让客户能够产生未知类型对象的选项。 3.在某些环境下，复制对象比创建新对象更有效。 缺点：对象的复制有时相当复杂 ...
JAVA-设计模式：AKA单例模式（结构型）
weixin_46524005的博客
07-24 144
一：（懒汉式&线程不安全）不考虑多线程时最直接的方法，第一次使用时才会初始化实例，线程不安全 public class Singleton { private static Singleton uniqueInstance; private Singleton() { } public static Singleton getInstance() { if (uniqueInstance == null) { uniq..
JAVA-设计模式：AKA策略模式（行为型）
weixin_46524005的博客
07-30 345
定义 定义了一些平行的算法组，分别封装起来，算法之间可以相互替换，此模式使算法的变化独立于调用者之外 优点：1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。 缺点：1、策略类会增多。 2、所有策略类都需要对外暴露。 注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。 算法结构 抽象策略角色（Strategy）：这是一个抽象类或接口，将算法的行为进行封装，所有的策略类都要实现该接口 具体策略角色（ConcreteStrategy）：封..
JAVA-设计模式：AKA桥接模式（结构型）
weixin_46524005的博客
08-03 238
AKA策略模式中最后的鸭子例子也是桥接模式 及策略与桥接模式区别 https://blog.csdn.net/weixin_46524005/article/details/107684421?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159641802019195188357345%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_i
office-docs-powershell：Office产品的PowerShell参考-短URL：aka.msoffice-powershell
02-17
短网址：aka.ms/office-powershell概述此存储库保留Office PowerShell cmdlet的参考内容以用于帮助目的。 有关Office PowerShell的专家知识分布在客户，MVP，合作伙伴，产品团队，支持和其他社区成员之间。 消费者在...
postcss-lolcat-stylesheets:Lolcat aka Lolspeak CSS属性
05-11
PostCSS Lolcat样式表 插件，用于编写Lolcat样式表。 Lolcat语法 . ohai { posishun : relativ; bakground-color : chawklit; bakground-image : none;... font-pplz : Helvetica , Arial;....... color : s
EAP-AKA-ns2:交接安全 - EAP AKA ERP - 框架实施
06-09
ns-2 的切换安全框架实现 EAP 又名 ERP 参考 RFC 4187、RFC 5296、RFC 5448 本硕士论文中描述了技术细节： :
azure-service-bus-go：用于Azure Service Bus的Golang库-https：aka.msazsb
01-28
适用于Golang的Microsoft Azure Service Bus客户端 Microsoft Azure服务总线是一种可靠的云消息传递服务（MaaS），可简化企业云消息传递。 它使开发人员能够构建可伸缩的云解决方案，并通过称为AMQP的有效二进制...
aka-tradingindo.com:aka-tradingindo.com
05-12
这是一个用引导的项目。入门首先，运行开发服务器：npm run dev# oryarn dev 用浏览器打开以查看结果...在Vercel上部署部署Next.js应用程序的最简单方法是使用Next.js创建者提供的。 请查看我们的以获取更多详细信息。
python 交叉验证后获取模型_Scikit-learn中的输出交叉验证模型（aka估计器）是什么？...
weixin_39966602的博客
02-09 117
这些模型正在做不同的事情 . SVC在您的完整特征空间上训练模型，并在整个特征空间上进行预测 . RFECV使用完整的功能空间并调整所选功能的数量 . 最终模型及其所做的任何预测都基于您的特征的子集(未消除的特征) .您可以检查RFECV对象以获取有关所选功能或执行各种功能子集的更多信息(请参阅RFECV documentation， . support_，.grid_scores_和.ran...
分布式日志解决方案ELK搭建基于Docker及Java使用
Fyf_010316的博客
11-21 382
ELK 使用前，我们先了解下ELK是什么 Elasticsearch + Logstash + Kibana（ELK）是一套开源的日志管理方案 Logstash：负责日志的采集，处理 Elasticsearch：负责日志存储和检索 Kibana：负责日志的可视化(Web界面) ELK的整体操作流程 首先是 logstash 收集各种日志并进行过滤 然后将过滤后的内容发送到 ES 服务中 最后...
数据结构之九大排序（JAVA）
Aka丶的博客
03-05 9257
最近面临实习面试，由于自己准备投开发岗，据了解在面试中对于数据结构的考察是很重要的，其中对于查找、排序的算法考察尤为重要，所以又重回当年学习的数据结构好好复习。参考：《数据结构》 严蔚敏版、《考研数据结构》及各排序总结博客，整理出适合自己的排序总结以供参考 http://www.open-open.com/lib/view/open1453126714683.html http://www
Java - 泛型
qq_35221384的博客
09-06 211
泛型
一些面试基本知识（JAVA篇一）
Aka丶的博客
03-18 6092
写在前面：准备面试已经一段时间了，这期间看了不少知识点，刷了不少题目，但是没怎么记录。今天上byr时无意间看到学姐整理的一份面试记录，感觉很不错。所以让我也产生了记录面试的念头，首先就从面试前的一些基础知识上开始吧，这些都是最基本的概念，还是有必要做一个全面的总结。附byr连接：https://bbs.byr.cn/#!article/Job/1877924?p=1JAVAjava内存，堆栈特点与存
JAVA学习第二周总结
Aka_bane的博客
03-12 224
通过前几周以及这周的学习之后，我对JAVA的学习有了更进一步的了解，同时也深刻的认识到学习一门编程语言兴趣尤为最重要。近期基本上都是学习的java的一些基本语法，在此之前学习了一个学期的python，因此在学习JAVA时明显感觉到了JAVA的复杂，还记得我编写的第一个经典程序“hello Word”。当时自己不是很理解为什么main方法一定要这样来定义public static void main...
Java：Java快速入门
weixin_33728268的博客
09-25 547
你好，世界！ 源代码组织方式 Java程序由package+class组成，package对应目录的相对路径，class对应文件，如 E:\Workspaces\MyEclipse 10\JavaStudy\src\com\happyframework\javastudy\hello\Hello.java 1 package com.happyframework.javastudy.h...
并发编程模型
ifeves的博客
05-07 495
并发系统可以采用多种并发编程模型来实现。并发模型指定了系统中的线程如何通过协作来完成分配给它们的作业。不同的并发模型采用不同的方式拆分作业，同时线程间的协作和交互方式也不...
计算机网络模型参考
m0_54594153的博客
05-31 217
文章目录 网络的分层思想 OSI七层参考模型 TCP/IP的模型和协议族 数据的封装与解封装 一、网络的分层思想 在网络的传输过程中，将复杂的流程分解为几个功能相对单一的子过程 整个流程更加清晰，复杂问题简单化 更容易发现问题并针对性解决问题 二、OSI七层参考模型 国际标准化组织（ISO） 1984年颁布了开发系统互连（OSI）参考模型 一个开放式体系结构，将网络分为七层 第七层：应用层 网络服务与最终用户的一个接口（用户操作） 第六层：表示层...
Invoke-WebRequest -Uri https://aka.ms/wslubuntu2004 -OutFile Ubuntu.appx -UseBasicParsing
最新发布
07-24
你可以使用上述的 PowerShell 命令来下载 Ubuntu 20.04 的应用包。该命令使用 `Invoke-WebRequest` 函数来下载指定的 URL，并将文件保存为 `Ubuntu.appx`。参数 `-UseBasicParsing` ...这样可以提高命令的执行效率。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值