`

jdk的观察模式学习

阅读更多

 Observer模式定义对象间的一对多的依赖关系,当一个对象(被观察者)的状态发生改变时, 所有依赖于它的对象(观察者)都得到通知并被自动更新。JDK里提供的observer设计模式的实现由java.util.Observable类和 java.util.Observer接口组成。从名字上可以清楚的看出两者在Observer 设计模式中分别扮演的角色:Observer是观察者角色,Observable是被观察目标(subject)角色。

 

import java.util.Observer;
import java.util.Vector;

/**
 * Observable 被观察对象
 * <p>
 * 一个 observable 对象可以有一个或多个观察者observer。
 * <p>
 * 观察者是实现Observer接口的任意对象。
 * <p>
 * 一个 observable 实例改变后,调用 Observable 的 notifyObservers 方法的应用程序会通过调用观察者的 update 方法来通知观察者该实例发生了改变。
 * <P>
 */

public class Observable {

    /** 被观察对象是否改变 */
    private boolean      changed = false;

    /**
     * 一个 observable 对象可以有一个或多个观察者observer
     * <p>
     * 该集合是用来存放该被观察对象的观察对象
     */
    private final Vector obs;


    public Observable(){
        obs = new Vector();
    }

    /**
     * Adds an observer to the set of observers for this object, provided that it is not the same as some observer
     * already in the set. The order in which notifications will be delivered to multiple observers is not specified.
     * See the class comment.
     * <p>
     * 如果观察者与集合中已有的观察者不同,
     * <p>
     * 则向对象的观察者集中添加此观察者。
     * <p>
     * 未指定向多个观察者发送通知的顺序。
     * 
     * @param o an observer to be added.
     * @throws NullPointerException if the parameter o is null.
     */
    public synchronized void addObserver(Observer o) {
        if (o == null) throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

    /**
     * Deletes an observer from the set of observers of this object. Passing <CODE>null</CODE> to this method will have
     * no effect.
     * <p>
     * 从对象的观察者集合中删除某个观察者。
     * <p>
     * 向此方法传递 null无效
     * 
     * @param o the observer to be deleted.
     */
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    /**
     * If this object has changed, as indicated by the <code>hasChanged</code> method, then notify all of its observers
     * and then call the <code>clearChanged</code> method to indicate that this object has no longer changed.
     * <p>
     * Each observer has its <code>update</code> method called with two arguments: this observable object and
     * <code>null</code>. In other words, this method is equivalent to: <blockquote><tt>
     * notifyObservers(null)</tt></blockquote>
     * <p>
     * 如果 hasChanged 方法指示对象已改变,则通知其所有观察者,并调用 clearChanged 方法来指示此对象不再改变。
     * <p>
     * 每个观察者都有其 update 方法,其调用参数有两个:observable 对象和 null。换句话说,此方法等效于: notifyObservers(null)
     * 
     * @see java.util.Observable#clearChanged()
     * @see java.util.Observable#hasChanged()
     * @see java.util.Observer#update(java.util.Observable, java.lang.Object)
     */
    public void notifyObservers() {
        notifyObservers(null);
    }

    /**
     * If this object has changed, as indicated by the <code>hasChanged</code> method, then notify all of its observers
     * and then call the <code>clearChanged</code> method to indicate that this object has no longer changed.
     * <p>
     * Each observer has its <code>update</code> method called with two arguments: this observable object and the
     * <code>arg</code> argument.
     * <p>
     * 如果 hasChanged 方法指示对象已改变,则通知其所有观察者,并调用 clearChanged 方法来指示此对象不再改变。
     * <p>
     * 每个观察者都有其 update 方法,其调用参数有两个:observable 对象和 arg 参数。 arg 可以是任意对象
     * 
     * @param arg any object.
     * @see java.util.Observable#clearChanged()
     * @see java.util.Observable#hasChanged()
     * @see java.util.Observer#update(java.util.Observable, java.lang.Object)
     */
    public void notifyObservers(Object arg) {
        /*
         * 是当前观察者的快照
         */
        Object[] arrLocal;

        synchronized (this) {
            /*
             * 使用synchronized (this),可以避免在多线程的状况下新加的观察者和未被注册的观测者被通知
             */
            if (!changed) return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length - 1; i >= 0; i--)
            ((Observer) arrLocal[i]).update(this, arg);
    }

    /**
     * Clears the observer list so that this object no longer has any observers.
     */
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    /**
     * Marks this <tt>Observable</tt> object as having been changed; the <tt>hasChanged</tt> method will now return
     * <p>
     * 标记此 Observable 对象为已改变的对象;现在 hasChanged 方法将返回 true。
     * <p>
     * <tt>true</tt>.
     */
    protected synchronized void setChanged() {
        changed = true;
    }

    /**
     * Indicates that this object has no longer changed, or that it has already notified all of its observers of its
     * most recent change, so that the <tt>hasChanged</tt> method will now return <tt>false</tt>. This method is called
     * automatically by the <code>notifyObservers</code> methods.
     * <p>
     * 指示对象不再改变,或者它已对其所有的观察者通知了最近的改变,所以 hasChanged 方法将返回 false。
     * <p>
     * notifyObservers 方法自动调用此方法。
     * <p>
     * 
     * @see java.util.Observable#notifyObservers()
     * @see java.util.Observable#notifyObservers(java.lang.Object)
     */
    protected synchronized void clearChanged() {
        changed = false;
    }

    /**
     * Tests if this object has changed.
     * 
     * @return <code>true</code> if and only if the <code>setChanged</code> method has been called more recently than
     * the <code>clearChanged</code> method on this object; <code>false</code> otherwise.
     * <p>
     * 测试对象是否改变。当且仅当在此对象上最近调用了 setChanged 方法时才返回 true;否则返回 false。
     * @see java.util.Observable#clearChanged()
     * @see java.util.Observable#setChanged()
     */
    public synchronized boolean hasChanged() {
        return changed;
    }

    /**
     * Returns the number of observers of this <tt>Observable</tt> object.
     * <p>
     * 返回 Observable 对象的观察者数目
     * 
     * @return the number of observers of this object.
     */
    public synchronized int countObservers() {
        return obs.size();
    }
}

 

 

Oberver接口

这是个接口类,这个接口只有一个未实现的抽象方法update。实现该接口的对象成为观察者,该对象要实现update方法。注册了该对象(观察者)的对象(观察者)实例调用notifiyObservers方法后,观察者会自动执行update方法。

public interface Observer {
    /**
     * This method is called whenever the observed object is changed. An
     * application calls an <tt>Observable</tt> object's
     *只要改变了 observable 对象就调用此方法。
     * <code>notifyObservers</code> method to have all the object's
     * observers notified of the change.
     *
     * @param   o     the observable object.
     * @param   arg   an argument passed to the <code>notifyObservers</code>
     *                 method.
     */
    void update(Observable o, Object arg);
}
 

 

 

 

 

 

 

 

分享到:
评论

相关推荐

    jdk中设计模式

    【设计模式概述】 设计模式是软件工程中经过实践...学习JDK中的设计模式可以让我们更好地理解Java库的设计思想,提升编程技巧,同时也能帮助我们更有效地运用这些模式到自己的项目中,编写出高质量、易于维护的代码。

    设计模式实战、jdk源码|simple-demo.zip

    创建型模式(如单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式)、结构型模式(如适配器模式、...模式、观察者模式、迭代器模式、访问者模式、命令模式、备忘录模式、状态模式、职责链模式、解释器模式)...

    jdk8源码包

    这种方法在设计模式如观察者模式中非常有用。通过源码,我们可以研究接口默认方法的实现机制以及它们在多继承中的处理策略。 对于Java 8的Optional类,它是用来解决null安全问题的一个工具类,源码解析可以帮助我们...

    jdk源代码src.zip

    深入研究JDK源代码,不仅可以帮助我们更好地理解和使用Java提供的各种API,还能让我们学习到优秀的编程实践和设计模式。比如,观察Collections类的静态工厂方法,可以学习如何编写高效且易于使用的工具类;研究...

    jdk1.8 src源码包

    - **学习设计模式**: JDK源码中广泛应用了许多经典设计模式,如工厂模式、单例模式和观察者模式等。 - **启发创新**: 通过学习源码,开发者可以从Oracle工程师的设计思路中汲取灵感,为自己的项目提供新的解决方案...

    JDK API 1.8 中文版 & JDK API 1.6 中文版

    3. **NIO.2 (New I/O 2)**: JDK 1.6引入了NIO.2,提供异步I/O操作,增加了文件系统相关的API,如文件路径、文件属性、文件观察者等。 4. **动态代理增强**: 支持接口中的默认方法,允许代理类实现接口的默认方法,...

    jdk1.8.0.rar

    这对于设计模式如观察者模式等提供了更大的灵活性。 此外,新版本还引入了方法引用来代替传统的匿名内部类,简化了代码。方法引用可以是静态方法引用、实例方法引用或构造器方法引用,使得代码更加紧凑且易于理解。...

    jdk api 1.8_google.CHM中文文档

    这在设计模式中非常有用,比如在实现观察者模式时。 7. **新的集合工厂方法**:`List`、`Set`和`Map`接口增加了新的工厂方法,如`of()`、`ofNullable()`和`copyOf()`,方便创建不可变集合。 8. **类型注解**:JDK ...

    jdk-8u241-docs-all.zip

    6. 面向对象设计模式:介绍了Java开发中的常见设计模式,如工厂模式、单例模式、观察者模式等,有助于提高代码的可重用性和可维护性。 7. 安全指南:阐述了Java的安全模型和策略,包括权限、证书、加密、网络安全等...

    详解Observer Pattern(观察者模式)在Java中的使用原理

    我们说学习Java应该从Swing开始,那么学习Swing最重要的思想就是对于观察者模式的理解(Observer Pattern)。因为,该设计模式在Java Swing框架中贯穿了始终。对于C#的委托、代理概念所使用的Callback(回调模式--...

    java jdk经典实例

    15. **设计模式**:学习常见的设计模式(如单例、工厂、观察者等)有助于编写更高效、可维护的代码。 通过实践这些Java JDK的经典实例,不仅可以巩固理论知识,还能提升解决实际问题的能力。不断练习和理解每个案例...

    jdk工具介绍JVM垃圾回收23种设计模式

    5. ...(剩余19种模式包括装饰者模式、适配器模式、观察者模式等,它们都有各自的用途和实现方式) 了解并熟练运用这些工具和设计模式,对于提升Java开发效率、优化系统性能和编写可维护的代码至关重要。通过深入...

    jdk5_8源码

    - **学习设计模式**:源码中充满了经典的设计模式,如工厂模式、单例模式、观察者模式等,这些模式在实际开发中广泛应用。 - **问题排查**:遇到Java运行异常时,查看源码能更快定位问题所在,理解其底层原因。 -...

    java JDK1.6.0源码 源代码

    - JDK源码中广泛运用了设计模式,比如工厂模式(用于创建对象)、单例模式(确保类只有一个实例)、装饰器模式(动态地给对象添加新的行为或职责)、观察者模式(定义对象间的一种一对多依赖关系,当一个对象的状态...

    全部java学习笔记JDK6课件,非常实用的资源

    在设计模式方面,笔记可能会涵盖一些经典的面向对象设计模式,如单例模式、工厂模式、观察者模式等,这些模式在实际开发中广泛应用,能提高代码的可重用性和可维护性。 最后,JDK6的API包括了大量的标准库,如集合...

    java 23种设计模式的类图

    23. **观察者模式(Observer)**:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。 以上就是23种设计模式的基本概念和应用,它们在实际开发中扮演着至...

    java观察者模式介绍

    JDK里提供的observer设计模式的实现由java.util.Observable类和 java.util.Observer接口组成。从名字上可以清楚的看出两者在Observer 设计模式中分别扮演的角色:Observer是观察者角色,Observable是被观察目标...

    设计模式学习笔记

    本学习笔记将重点关注“观察者模式”,这是一种行为设计模式,用于在对象之间定义一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。 观察者模式的主要组成部分包括...

    JDK_API_1_6 官方中文版

    3. **NIO.2**:Java 1.6引入了新的非阻塞I/O API(NIO.2),提供了异步文件操作和更高级的文件系统功能,如文件路径操作和文件观察者。 4. **Swing增强**:Swing库得到了大量更新,包括新的Look and Feel设计,以及...

    面向对象初学者必须掌握的几种设计模式

    观察者模式 Observer:Swing中的事件模型 工厂模式 Factory:在JDK中遍地都是,比如JDBC、JNDI等,是学习Spring的基础 命令模式 Command:Struts框架的基石 单例模式 Singleton:最简单的设计模式,大量...

Global site tag (gtag.js) - Google Analytics