观察者设计模式(observer)

最新推荐文章于 2024-05-03 16:12:22 发布
最新推荐文章于 2024-05-03 16:12:22 发布
阅读量68 收藏
点赞数
文章标签： java 设计模式

Observer(观察者)模式是比较常用的一个模式,他让主题和观察者之间松耦合

定义:定义对象间一对多的依赖,这样一来,当一个对象发生改变,其他依赖者会得到通知并自动更新.

作为观察者,主题只知道他实现一个接口Oberver,主题不需要知道他具体是谁,需要实现什么操作.

任何时候我们都可以增加新的观察者.因为主题实现的是一个实现oberver的抽象接口列表,所以我们可以随时增加和删除观察者

主题不用了解其他的,只需要给现有注册的观察者发消息就可以了,观察者的增加和改变,不需要修改主题的代码.

主题和观察者,我们可以重复使用,改变一方不会影响另外一方，说到底就是为了达到解耦合的目的.

应用场合：

新京报,他是一个主题,很多人都可以定购他,他不需要了解你订购他是干吗,他只知道你付了钱,他给你一份报纸,到什么地址.如果他修改版面,他会通知你,比如说,最近物价上涨.可能需要上涨几毛钱.(有更改就会通知依赖者)

而订购他的人或者公司,属于观察者也就是依赖者,只有2个参数,一个是注册,一个是解除注册.注册后,就会收到报纸的最新消息,一有修改就会通知你.解除注册后,你还是你,但是你已经不属于依赖者了,就不会接到相应的消息.你可以今天注册,今天解除(这是你的事情).不会影响到其他的东西,也就是松耦合.


首先我们来模拟JDK里面有自带的类实现观察者模式：

实现一个电脑厂商和地区代理的示例,一对多关系依赖

GeneralProxy.java

package com.linpyi.computer;

/** 
 * 电脑总代理接口 
 * @author work 
 * 
 */  
public interface GeneralProxy {  
    /** 
     * 注册电脑代理 
     * @param o 
     */  
    public void registerComputerProxy(Observer o);  
    /** 
     * 移除电脑代理 
     * @param o 
     */  
    public void removeComputerProxy(Observer o);  
    /** 
     * 更新代理价格 
     */  
    public void notifyComputerProxy();  
}

Observer.java

package com.linpyi.computer;  
  
/** 
 * 电脑观察者,自己写的代理接口 
 * @author work 
 * 
 */  
public interface Observer {  
    /** 
     * 更新电脑信息 
     * @param name 电脑品牌 
     * @param price 电脑价格 
     * @param info 电脑描述 
     */  
    public void update(String name,float price,String info);  
}

BranchProxy.java 

package com.linpyi.computer;  
/** 
 * 电脑分代理接口 
 * @author work 
 * 
 */  
public interface BranchProxy {  
    /** 
     * 默认方法 
     */  
    public void display();  
}
LenvoComputer.java 

package com.linpyi.computer;  
  
import java.util.ArrayList;  
  
/** 
 * lenovo电脑
 * @author work 
 * 
 */  
public class LenvoComputer implements GeneralProxy {  
      
    private ArrayList proxys ;  
    private String name;  
    private float price;  
    private String info;  
      
    public LenvoComputer(){  
        proxys = new ArrayList();  
    }
      
    /** 
     * 更改lenvo分代理的信息 
     */  
    public void notifyComputerProxy() {  
        for(int i = 0 ;i<proxys.size();i++){  
            Observer proxy = (Observer)proxys.get(i);  
            proxy.update(name, price, info);
        }
    }
      
    /** 
     * 设置lenvo的电脑价格和信息 
     * @param name 电脑名称 
     * @param price 电脑价格 
     * @param info 电脑描述信息 
     */  
    public void setLenvo(String name,float price,String info){  
        this.name=name;  
        this.price=price;  
        this.info=info;  
        notifyComputerProxy();  
    }
  
    /** 
     * 注册lenvo代理 
     */  
    public void registerComputerProxy(Observer o) {  
        proxys.add(o);  
    }  
  
    /** 
     * 移除lenvo代理 
     */  
    public void removeComputerProxy(Observer o) {  
        // TODO Auto-generated method stub  
        int i = proxys.indexOf(o);  
        if(i>=0){  
            proxys.remove(o);  
        }  
    }
}

ChinaProxy.java 

package com.linpyi.computer;  
  
/** 
 * 中国地区代理类,使用自己写的代理接口 
 * @author  
 * 
 */  
public class ChinaProxy implements BranchProxy, Observer {  
      
    private GeneralProxy generalProxy;  
    private String name ;  
    private float price;  
    private String info;  
      
    public ChinaProxy(GeneralProxy generalProxy){  
        this.generalProxy=generalProxy;  
        generalProxy.registerComputerProxy(this);//注册代理  
    }  
  
    /** 
     * 默认方法 
     */  
    public void display() {  
        // TODO Auto-generated method stub  
        System.out.println("中国代理");  
        System.out.println("型号"+name);  
        System.out.println("价格"+price);  
        System.out.println("描述信息"+info);  
    }  
  
    /** 
     * 更新方法 
     */  
    public void update(String name, float price, String info) {  
        // TODO Auto-generated method stub  
        this.name=name;  
        this.price=price;  
        this.info=info;  
        display();  
    }  
  
}

JapanProxy.java 

package com.linpyi.computer;  
  
/** 
 * 日本代理,使用自己写的代理接口 
 *  
 * @author work 
 *  
 */  
public class JapanProxy implements BranchProxy, Observer {  
  
    private String name;  
    private String info;  
    private float price;  
    private GeneralProxy generalProxy;
  
    public JapanProxy(GeneralProxy generalProxy) {  
        this.generalProxy = generalProxy;  
        generalProxy.registerComputerProxy(this);  
    }  
  
    public void update(String name, float price, String info) {  
        this.name = name;  
        this.price = price;  
        this.info = info;  
        display();  
    }
  
    public void display() {  
        // TODO Auto-generated method stub  
        System.out.println("日本代理");  
        System.out.println("型号" + name);  
        System.out.println("价格" + price);  
        System.out.println("描述信息" + info);  
    }
}
Client.java 

package com.linpyi.computer;

public class Client {

    public static void main(String[] args){  
        //使用自己写的观察模式方法  
        LenvoComputer lenvo = new LenvoComputer();  
        ChinaProxy chinaProxy  = new ChinaProxy(lenvo);  
        JapanProxy japanProxy  = new JapanProxy(lenvo);  
        lenvo.setLenvo("lenvo0001", 8000, "disk 160G , memory 2G");  

    }
}
使用JDK里面有自带的类实现观察者模式：

HpComputer.java

package com.linpyi.computer;  
  
import java.util.Observable;  
  
/** 
 * HP电脑代理,使用的是JDK自带的观察者模式类(Observable) 
 * @author work 
 * 
 */  
public class HpComputer extends Observable {  
  
    private String name;  
    private float price;  
    private String info;  
      
    public void measurementsChanged(){  
        setChanged();//观察者类里的方法,主要用于开关  
        notifyObservers();//继承类里的方法(通知观察者)  
    }  
      
    public void setMeasurements(String name,float price,String info){  
        this.name=name;  
        this.price=price;  
        this.info=info;  
        measurementsChanged();  
    }  
      
    public String getName(){  
        return name;  
    }  
      
    public float getPrice(){  
        return price;  
    }  
      
    public String getInfo(){  
        return info;  
    }  
    

}

IndiaProxy.java 

package com.linpyi.computer;  
  
import java.util.Observable;  
import java.util.Observer;  
  
/** 
 * 印度电脑代理(使用JDK自带的接口) 
 * @author work 
 * 
 */  
public class IndiaProxy implements Observer, BranchProxy {  
      
    private Observable observable;  
    private String name;  
    private String info;  
    private float price;  
      
    public IndiaProxy(Observable observable) {  
        this.observable = observable;  
        observable.addObserver(this);//增加观察者(JDK自带的)  
    }  
  
    /** 
     * 更新方法,使用的是JDK自带的方法 
     */  
    public void update(Observable o, Object arg) {  
        // TODO Auto-generated method stub  
        if (o instanceof HpComputer) {  
            HpComputer computer = (HpComputer) o;  
            this.name = computer.getName();  
            this.price = computer.getPrice();  
            this.info = computer.getInfo();  
            display();  
        }  
    }  
  
    public void display() {  
        // TODO Auto-generated method stub  
        System.out.println("印度代理");  
        System.out.println("型号" + name);  
        System.out.println("价格" + price);  
        System.out.println("描述信息" + info);  
    }  
  
}

KoreaProxy.java 

package com.linpyi.computer;  
  
import java.util.Observable;  
import java.util.Observer;  
  
/** 
 * 韩国代理,使用的是JDK自带的接口(Observer) 
 * @author work 
 * 
 */  
public class KoreaProxy implements Observer, BranchProxy {  
    private Observable observable;  
    private String name;  
    private String info;  
    private float price;  
  
    public KoreaProxy(Observable observable) {  
        this.observable = observable;  
        observable.addObserver(this);  
    }
  
    public void update(Observable o, Object arg) {  
        // TODO Auto-generated method stub  
        if (o instanceof HpComputer) {  
            HpComputer computer = (HpComputer) o;  
            this.name = computer.getName();  
            this.price = computer.getPrice();  
            this.info = computer.getInfo();  
            display();  
        }  
    }  
  
    public void display() {  
        // TODO Auto-generated method stub  
        System.out.println("韩国代理");  
        System.out.println("型号" + name);  
        System.out.println("价格" + price);  
        System.out.println("描述信息" + info);  
    }  
  
}

Client.java 

package com.linpyi.computer;

public class Client {

    public static void main(String[] args){  
    	//使用JDK的观察模式方法  
    	HpComputer hp = new HpComputer();  
    	KoreaProxy koreaProxy = new KoreaProxy(hp);  
    	IndiaProxy IndiaProxy = new IndiaProxy(hp);  
    	hp.setMeasurements("hp0001", 7000, "disk 250G , memory 10G");  

    }
}

JDK里面有自带的类实现观察者模式,在java.util.Observable,注意这是类而不是接口,类有类的局限性,因为JAVA只能继承


iteye_12837
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
设计模式C++学习之观察者模式（Observer）
09-07
设计模式C++学习之观察者模式（Observer）
设计模式——Observer(观察者)模式
qq_36566262的博客
04-21 2048
目录前言1 定义2 适用性3 结构3.1 结构图3.2 参与者4 应用举例4.1 Subject——Observable4.2 ConcreteSubject——ClockSubject4.3 Observer——Observer4.4 ConcreteObserver——ObserverOne、ObserverTwo4.5 测试程序——Client5 总结参考文献 前言 当一个对象与其它对象紧密关联，如果直接引用的话可能导致紧密耦合，如何描述这种一对多的关联关系？本文的观察者模式是一种思路。 1 定义 O
Java设计模式-观察者模式(Observer)
qq_37400096的博客
10-02 515
观察者模式在实际应用中比较多的，比如消息订阅，当消息更新变更会自动通知所有的订阅者。
设计模式第5讲——观察者模式（Observer）
让~学习~成为一种习惯（橡 皮 人の技术博客）
06-02 8713
观察者模式属于行为型模式。一、什么是观察者模式 二、特点 三、组成 四、应用场景4.1 生活场景4.2 程序场景 五、观察者模式实现5.0 UML类图5.1 Newspaper5.2 NewspaperImpl5.3 Subscriber5.4 SubscriberImpl5.5 测试
设计模式—观察者模式（Observer）
一起加油吧~
08-29 762
又叫发布-订阅（publish/Subscrib）模式。定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。观察者类似于卧底这样一个角色。在上班的时候，难免会有人趁老板不在的时候做一些工作之外的事情，例如炒炒股，看看NBA之类的，那如何应对老板突然回来这件事情呢？我们就需要卧底这样一个人给我们放风，老板一回来就通知这些人“老板回来了”。这其实就是一种观察者模式。
观察者模式 Observer模式
weixin_48927323的博客
11-22 583
观察者Observer模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新(做出不同的动作）。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。
观察者模式（Observer）原理图
04-18
观察者模式（Observer Pattern）是一种对象行为型设计模式，它定义了对象之间的一对多依赖关系。 当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式通常用于实现分布式事件处理系统...
C++设计模式之观察者模式（Observer）
08-27
主要为大家详细介绍了C++设计模式之观察者模式Observer，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
php设计模式 Observer(观察者模式)
10-28
定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新 能够便利地创建查看目标对象状态的对象,并且提供与核心对象非耦合的指定功能
Day25-Java基础之常用类1
m0_46053885的博客
04-27 1124
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
yajunjiao的专栏
04-30 503
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1100
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
Java解决最长公共前缀
无人罪的博客
04-28 396
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 909
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
Spring cloud原理详解
qq_33449977的博客
04-28 482
想象一下，你开了一家餐馆，一开始只卖汉堡，后来生意火了，你又增加了炸鸡、披萨、冰淇淋各种摊位，每个摊位就是一个微服务，它们各自独立工作，但又得相互配合。有时候，某个服务可能太忙了，电话老打不通，这时候Spring Cloud还有个叫Hystrix的断路器，它会说：“嘿，别打了，那边线路忙，我给你个备用方案或者告诉你稍后再试。至于餐馆运营情况，Spring Cloud Sleuth和Zipkin这些工具，就像监控摄像头，记录服务间的每一次交互，方便你查看哪里出了问题，优化服务流程。
Nacos 配置中心实例分析实践
最新发布
m0_73557631的博客
05-03 492
​ 浏览器: http://localhost:5000/nacos/config/ip。先创建e-commerce-nacos-config-client5000 模块。​ 启动e-commerce-nacos-config-client5000。​ 启动Nacos Server。
【限流】基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
qq_43209531的博客
04-30 431
基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 1066
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
埃氏筛选-判断素数
qq_45706306的博客
04-27 306
筛选：从最小的质数2开始，将它的所有倍数标记为合数（非质数），即把 isshushu 数组中对应索引位置的值设置为 true。计数：在筛选过程中，每当遇到一个未被标记为合数的数（即 isshushu 数组中对应值为 false 的数），则它就是一个质数，增加质数计数器 count 的值。返回结果：当所有小于 n 的数都经过筛选后，返回质数计数器 count 的值，即小于 n 的质数数量。通过这种方式，代码能够高效地找出并计算给定范围内质数的数量，避免了逐一检查每个数是否为质数的低效方法。
观察者设计模式java
11-21
观察者设计模式是一种常见的设计模式，用于在对象之间建立一对多的依赖关系。在该模式中，一个主题（被观察者）维护了一个观察者列表，并在自身状态发生变化时通知所有观察者进行相应的更新。下面是Java中观察者设计...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值