`

设计模式之——观察者模式

 
阅读更多
原摘取至百度百科

简介:

     观察者模式(Observer)完美的将观察者和被观察的对象分离开。举个例子,用户界面可以作为一个观察者,业务数据是被观察者,用户界面观察业务数据的变化,发现数据变化后,就显示在界面上。面向对象设计的一个原则是:系统中的每个类将重点放在某一个功能上,而不是其他方面。一个对象只做一件事情,并且将他做好。观察者模式在模块之间划定了清晰的界限,提高了应用程序的可维护性和重用性。
观察者设计模式定义了对象间的一种一对多的依赖关系,以便一个对象的状态发生变化时,所有依赖于它的对象都得到通知并自动刷新。

实现方式:
     观察者模式有很多实现方式,从根本上说,该模式必须包含两个角色:观察者和被观察对象。

原理:
     事件,也就是观察者与被观察者解耦,一定程度上分离开来(本质上是针对接口的编程,而不是针对实现的编程)
    [img]

[/img]
实现过程:

     注册——通知——撤销注册
     如图:
     [img]

[/img]
    观察者:
           (Observer)将自己注册到被观察对象(Subject)中,被观察对象将观察者存放在一个容器(Container)里。
     被观察:
           被观察对象发生了某种变化(如图中的SomeChange),从容器中得到所有注册过的观察者,将变化通知观察者。
     撤销观察:
           观察者告诉被观察者要撤销观察,被观察者从容器中将观察者去除。
观察者将自己注册到被观察者的容器中时,被观察者不应该过问观察者的具体类型,而是应该使用观察者的接口。这样的优点是:假定程序中还有别的观察者,那么只要这个观察者也是相同的接口实现即可。一个被观察者可以对应多个观察者,当被观察者发生变化的时候,他可以将消息一一通知给所有的观察者。基于接口,而不是具体的实现——这一点为程序提供了更大的灵活性。

使用场景:
             同一个发生源,需要针对不同事件类型做出不同的判断处理。
             同一个发生源,同一种事件类型,需要不同的处理方式。
//观察者,需要用到观察者模式的类需实现此接口
public interface Observer{
    void update(Object...objs);
}
 
//被观察者(一个抽象类,方便扩展)
public abstract class Observable{
 
    public final ArrayList<Class<?>> obserList = new ArrayList<Class<?>>();
 
    /**AttachObserver(通过实例注册观察者)
    *<b>Notice:</b>obcan'tbenull,oritwillthrowNullPointerException
    **/
    public<T> void registerObserver(T ob){
        if(ob==null) throw new NullPointerException();
        this.registerObserver(ob.getClass());
    }
 
    /**
    *AttachObserver(通过Class注册观察者)
    *@paramcls
    */
    public void registerObserver(Class<?> cls){
        if(cls==null) throw new NullPointerException();
        synchronized(obserList){
            if(!obserList.contains(cls)){
                obserList.add(cls);
            }
        }
    }
 
    /**UnattachObserver(注销观察者)
    *<b>Notice:</b>
    *<b>ItreverseswithattachObserver()method</b>
    **/
    public<T>void unRegisterObserver(Tob){
        if(ob==null) throw new NullPointerException();
        this.unRegisterObserver(ob.getClass());
    }
 
    /**UnattachObserver(注销观察者,有时候在未获取到实例使用)
    *<b>Notice:</b>
    *<b>ItreverseswithattachObserver()method</b>
    **/
    public void unRegisterObserver(Class<?>cls){
        if(cls==null) throw new NullPointerException();
        synchronized(obserList){
            Iterator<Class<?>>iterator=obserList.iterator();
            while(iterator.hasNext()){
                if(iterator.next().getName().equals(cls.getName())){
                    iterator.remove();
                    break;
                }
            }
        }
    }
 
    /**detachallobservers*/
    public void unRegisterAll(){
        synchronized(obserList){
            obserList.clear();
        }
    }
 
    /**Ruturnthesizeofobservers*/
    public int countObservers(){
        synchronized(obserList){
            returnobserList.size();
        }
    }
 
    /**
    *notify all observer(通知所有观察者,在子类中实现)
    *@paramobjs
    */
    public abstract void notifyObservers(Object... objs);
 
    /**
    *notify one certain observer(通知某一个确定的观察者)
    *@paramcls
    *@paramobjs
    */
    public abstract void notifyObserver(Class<?> cls, Object... objs);
 
    /**
    *notifyonecertainobserver
    *@paramcls
    *@paramobjs
    */
    public abstract<T> void notifyObserver(T t, Object... objs);
}
 
//目标被观察者
public class ConcreteObservable extends Observable{
 
    private static ConcreteObservableinstance = null;
    private ConcreteObservable(){};
    public static synchronized ConcreteObservablegetInstance(){
        if(instance == null){
            instance=newConcreteObservable();
        }
        returninstance;
    }
 
    @Override
    public <T> void notifyObserver(T t, Object... objs){
        if(t == null) throw new NullPointerException();
        this.notifyObserver(t.getClass(), objs);
    }
 
    @Override
    public void notifyObservers(Object... objs){
        for(Class<?>cls : obserList){
            this.notifyObserver(cls, objs);
        }
    }
 
 
    //通过java反射机制实现调用
    @Override
    public void notifyObserver(Class<?>cls, Object...objs){
        if(cls == null) throw new NullPointerException();
        Method[] methods = cls.getDeclaredMethods();
        for(Method method : methods){
            if(method.getName().equals("update")){
                try{
                    method.invoke(cls,objs);
                    break;
                }catch(IllegalArgumentException e){
                    e.printStackTrace();
                }catch(IllegalAccessException e){
                    e.printStackTrace();
                }catch(InvocationTargetException e){
                    e.printStackTrace();
                }
            }
        }
    }
}
 
//使用(实现Observer接口)
public class Text extends Activity implements Observer{
    publicvoidonCreate(...){
        ConcreteObservable.getInstance().registerObserver(Text.class);
        ....
    }
 
    //实现接口处理
    publicvoidupdate(Object...objs){
        //做操作,比如更新数据,更新UI等
    }
}

  • 大小: 42.8 KB
分享到:
评论

相关推荐

    设计模式实现——观察者模式

    在《设计模式实现——观察者模式》这篇博客中,作者可能详细解释了观察者模式的概念、结构以及其在实际编程中的应用。以下是对观察者模式的详细阐述: 1. **模式定义**:观察者模式是一种对象行为型模式,它允许...

    Java设计模式——观察者模式

    首先,我们来看"Java设计模式——观察者模式的两种情况": 1. **主动通知**: 在这种情况下,被观察者对象在自身状态发生变化时,会主动调用`Observable`接口提供的`notifyObservers()`方法,将变化通知给所有注册的...

    Android设计模式——观察者模式

    简单易懂的观察者模式

    深入浅出设计模式二——WeatherData设计(观察者模式)实现一

    在本文中,我们将深入探讨设计模式中的一个经典案例——观察者模式(Observer Pattern),通过具体的实现来理解其工作原理。观察者模式是一种行为设计模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生...

    KWIC 程序示例 事件风格 观察者模式

    在这个程序示例中,结合了事件风格和观察者模式,这两种设计模式在软件工程中都扮演着重要的角色。 **事件风格编程** 是一种编程范式,它将程序设计为对特定事件的响应。在事件驱动的系统中,程序的执行不依赖于...

    设计模式之美——教你写出高质量代码

    "设计模式之美——教你写出高质量代码"这个主题旨在帮助开发者更好地理解和应用设计模式,从而提升代码的质量和可维护性。设计模式不仅对面试有所帮助,也是职场发展中的必备技能,无论你使用哪种开发语言。 设计...

    深入浅出设计模式二——WeatherData设计(观察者模式)实现二

    在本文中,我们将深入探讨设计模式中的"观察者模式",并以`WeatherData`为例进行具体实现。观察者模式是一种行为设计模式,它允许我们定义一个订阅机制,当对象状态发生变化时,可以通知所有依赖它的观察者。这种...

    Android 设计模式:(二)观察者模式 —— 让你的对象知悉现况

    本文将深入探讨其中的一种——观察者模式(Observer Pattern)。观察者模式是一种行为设计模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。 ### ...

    C#设计模式(17)——观察者模式(Observer Pattern).pdf

    从中,我们就可以得出观察者模式的定义。  观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象,这个主题对象在状态发生变化时,会通知所有观察者对象,使它们能够自动更新自己的行为...

    Android 设计模式:(一)观察者模式 —— 封装行为的大局观

    本文将深入探讨其中的一种——观察者模式(Observer Pattern),它是行为设计模式的一种,主要用来封装行为的变化,实现对象间一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并被...

    设计模式-观察者

    《设计模式——观察者》 在软件工程中,设计模式是一种在特定情境下解决常见问题的经验总结,它们是经过反复验证的最佳实践。观察者模式(Observer Pattern)是行为设计模式的一种,它定义了对象之间的一对多依赖...

    [行为模式]head first 设计模式之观察者模式(observer)

    观察者模式(Observer Pattern)是设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式在软件开发中广泛应用于事件驱动...

    设计模式——刘伟

    3. **观察者模式**:定义对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。在事件驱动编程中广泛使用,例如GUI组件间的交互。 4. **装饰器模式**:动态地给一个...

    Android 设计模式学习之观察者模式应用实例

    本文将深入探讨一种常用的设计模式——观察者模式(Observer Pattern),并结合Android实际应用给出实例解析。 观察者模式是一种行为设计模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,...

    设计模式代码——c#

    16. 观察者模式(Observer Pattern) 17. 解释器模式(Interpreter Pattern) 18. 中介者模式(Mediator Pattern) 19. 职责链模式(Chain of Responsibility Pattern) 20. 备忘录模式(Memento Pattern) 21. ...

    设计模式——GFour

    行为型模式主要关注对象间职责的分配和通信,包括责任链模式、命令模式、解释器模式、迭代器模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式和访问者模式。这些模式有助于我们更好地管理对象的行为...

    设计模式——原版的设计模式

    观察者模式定义了对象之间的一对多依赖关系,当一个对象的状态改变时,所有依赖于它的对象都会得到通知并被自动更新;状态模式允许一个对象在其内部状态改变时改变它的行为,看起来它好像修改了它的类;策略模式定义...

    《java设计模式》课后习题模拟试题解答——刘伟.zip

    本资料“《java设计模式》课后习题模拟试题解答——刘伟.zip”主要涵盖了Java设计模式的学习与应用,特别是针对刘伟教授的相关课程的课后习题及模拟试题的解答。 设计模式分为三大类:创建型、结构型和行为型模式。...

    PHP设计模式介绍——CHM

    - 观察者模式:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。 - 状态模式:允许对象在其内部状态改变时改变它的行为,对象看起来似乎修改了它的类...

Global site tag (gtag.js) - Google Analytics