java设计模式 GOF23 12 观察者模式

一.观察者模式简介

  当一个对象变化时,其它依赖该对象的对象都会收到通知,并且随着变化!对象之间是一种一对多的关系。

二.实际应用

  聊天室,消息订阅

  在这些应用场景下,订阅者和聊天客户端称之为观察者,需要同步到多个订阅者的数据封装到对象中,

  称之为目标。

三.模式核心

  观察者模式是一对多的通知,当一个对象发生变化时,他需要告诉每一个对象。

  通知观察者的方式:

    1)推:观察者只能被动接受消息

    2)拉:观察者可以自行决定是否接收消息。

  消息对象通过容器存放所有观察者,消息更新时通过遍历容器通知每一个观察者更新消息。  

四.简单代码实现

package com.lz.observer;

/*
 * 观察者接口
 */
public interface IObserver {
    void update(Subject sub);
}
package com.lz.observer;

public class Observer implements IObserver{

    private int thisValue;

    public int getThisValue() {
        return thisValue;
    }

    public void setThisValue(int thisValue) {
        this.thisValue = thisValue;
    }

    @Override
    public void update(Subject sub) {
        thisValue = ((ConcreteSubject)sub).getValue();
    }
}
package com.lz.observer;

import java.util.ArrayList;
import java.util.List;

public class Subject {
    /*
     * 存放观察者的容器
     */
    protected List<IObserver> list = new ArrayList<IObserver>();

    public void addIObserver(IObserver iobs) {
        list.add(iobs);
    }

    public void remove(IObserver iobs) {
        list.remove(iobs);
    }

    /*
     * 状态发生变化时会通知所有观察者
     */
    protected void notifyAllObserver() {
        for (IObserver iObserver : list) {
            iObserver.update(this);
        }
    }
}
package com.lz.observer;

public class ConcreteSubject extends Subject{
    private int value;

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
        notifyAllObserver();
    }

}
package com.lz.observer;

public class Client {
    public static void main(String[] args) {
        ConcreteSubject sub = new ConcreteSubject();
        /*
         * 观察者
         */
        Observer obs1 = new Observer();
        Observer obs2 = new Observer();
        Observer obs3 = new Observer();
        sub.addIObserver(obs1);
        sub.addIObserver(obs2);
        sub.addIObserver(obs3);
        sub.setValue(100);

        System.out.println(obs1.getThisValue());
        System.out.println(obs2.getThisValue());
        System.out.println(obs3.getThisValue());

        sub.setValue(200);
        System.out.println(obs1.getThisValue());
        System.out.println(obs2.getThisValue());
        System.out.println(obs3.getThisValue());
    }
}

  

  

时间: 2024-08-09 06:32:08

java设计模式 GOF23 12 观察者模式的相关文章

java设计模式之:观察者模式

package Observer; public class Test { /** * 客户端测试类 * 观察者模式一般由四部分组成: * 1抽象的被观察者(一般教材上都叫做"Subject(抽象的主题类)"), * 里面一般定义了抽象的add(),remove(),notifyAll()等方法, * 分别用于增加观察者,删除观察者,通知观察者自己的变化. * 2具体的观察者类(一般教材上都叫做"ConcreteSubject(具体的主题类)"), * 是抽象的被观

java设计模式 GOF23 09 组合模式

一.组合模式简介 把整体和部分的关系用树形结构表示,从而可以统一处理. 二.组合模式实现细节 1)抽象构建:定义叶子和容器的共同特点. 2)叶子:没有子节点 3)容器:有容器的特征,可以包含子节点(一般实现的时候在这里添加容器存放子节点) 三.简单代码实现 package com.lz.combination; import java.util.ArrayList; import java.util.List; /* * 抽象构建 */ public interface IComponent {

java设计模式 GOF23 05 适配器模式

一.适配器模式简介 java中一个类想要使用与自己毫不相干的另一个对象时,最简单的方法是使用适配器模式. 下面是简单代码实现: package com.lz.adapter; /* * 被适配对象 */ public class Adaptee { public void request() { System.out.println("提供相关服务."); } } package com.lz.adapter; /* * 实现了适配接口的适配器 */ public class Adap

java设计模式 GOF23 04 原型模式

一.原型模式介绍 因为java中new一个新对象比clone一个对象需要花费等多的资源,所以一般需要 在短时间内创建大量对象并且new对象的过程需要耗费比较多的资源使用原型模式. 想要clone一个类需要这个类实现Cloneable接口,重载clone方法,这个接口在底层 通过内存拷贝实现clone对象,因此效率很高. package com.lz.prototype; import java.util.Date; public class ShallowClone implements Clo

java设计模式 GOF23 11 享元模式

一.享元模式简介 如果有很多相同或者相似的对象可以使用享元模式,从而节约内存. 二.关键点 享元对象需要区分内部状态和外部状态. 内部状态:可以共享,不会随着外部状态改变. 外部状态:不可以共享,随外部状态改变. 享元共享类实现享元池管理享元对象. 三.简单实现 package com.lz.flyWeight; /* * 享元模式 * 内部状态 * 模拟棋盘,因为一盘棋其中棋子的颜色都一样 * 只有位置不一样,所以可以将颜色共享,这样可以节省内存空间 * 棋盘接口 */ interface C

java设计模式 GOF23 10 外观模式

一.外观模式简介 外观模式是为了解决类与类之间的依赖关系,这种模式将类与类之间的关系放到一个Facade类中,从而降低类与类之间的耦合. 二.简单代码实现 package com.lz.facade; /* * 外观模式 * 门面对象 */ public class RegisterFacade { public void register() { new 南京工商局().checkName(); new 南京税务局().taxCertificata(); } } package com.lz.

java设计模式 GOF23 03 建造类模式

package com.lz.builder; /* * 组装者实现类,提供一个可以获取产品的公共方法 */ public class LzCarDirector implements CarDirector{ private CarBuilder cb; private Car car; public LzCarDirector(CarBuilder cb) { this.cb = cb; } @Override public Car CarDirector() { Car car = new

java设计模式 GOF23 02 工厂模式

package com.lz.factory.simpleFactory; /* * * 补充:面向对象基本原则 * OCP:(开闭原则)添加新功能不应该修改原有代码,而是添加新的类 * DIP:(依赖倒转原则)依赖接口编程 * LOD:(迪米特法则)降低耦合,只和必要的对象通信 * 静态工厂类 { * 创建者和调用者的分离 * * 简单工厂问题:添加新功能需要修改代码 * } * 工厂方法类{ * 代码过多 * } * 两者比较 * 简单工厂结构代码更简单 * 工厂方法更难维护 * 总结:工厂

理解java设计模式之观察者模式

在生活实际中,我们经常会遇到关注一个事物数据变化的情况,例如生活中的温度记录仪,当温度变化时,我们观察它温度变化的曲线,温度记录日志等.对于这一类问题,很接近java设计模式里面的“观察者模式”,它适合解决多种对象跟踪一个对象数据变化的程序结构问题. 观察者设计模式涉及到两种角色:主题(Subject)和观察者(Observer) 下面以java JDK中已有的观察者设计模式代码,展示使用: 1.主题(Subject):Observable类派生出来的子类,只需要定义各被监控的数据及getter