设计模式11---观察者模式

观察者模式实质就是提取:提取监听对象的过程是相同的,也就是说observer类为根据不同的subject的状态做出相应的反应。

package com.jayfulmath.designpattern.observer;

public abstract class Observer {

    protected String name;
    protected ISubject sub;    

    public Observer(String name, ISubject sub) {
        this.name = name;
        this.sub = sub;
    }
    public abstract void Update();
}
public interface ISubject {
    public void Attach(Observer obs);
    public void Detach(Observer obs);
    public void Broadcast();
    public String getSubjectStatus();
    public void setSubjectStatus(String subjectStatus);
}

public class NBALooker extends Observer {

public NBALooker(String name, ISubject sub) {
        super(name, sub);
        // TODO Auto-generated constructor stub
    }

@Override
    public void Update() {
        System.out.println(sub.getSubjectStatus()+"\t"+name+"\tstop NBA Look");
    }

}

public class NBALooker extends Observer {

    public NBALooker(String name, ISubject sub) {
        super(name, sub);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void Update() {
        System.out.println(sub.getSubjectStatus()+"\t"+name+"\tstop NBA Look");
    }

}
public class StockLooker extends Observer {

    public StockLooker(String name, ISubject sub) {
        super(name, sub);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void Update() {
        // TODO Auto-generated method stub
        System.out.println(sub.getSubjectStatus()+"\t"+name+"\tstop Stock Look");
    }

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

public class Boss implements ISubject {

    List<Observer> _mObservers = new ArrayList<Observer>();
    public String subjectStatus;

    public void Attach(Observer obs)
    {
        _mObservers.add(obs);
    }

    public void Detach(Observer obs)
    {
        _mObservers.remove(obs);
    }

    public void Broadcast()
    {
        //here may be asynchronous to notify observer
        for(Observer observer :_mObservers)
        {
            observer.Update();
        }
    }

    /**
     * @return the subjectStatus
     */
    public String getSubjectStatus() {
        return subjectStatus;
    }

    /**
     * @param subjectStatus the subjectStatus to set
     */
    public void setSubjectStatus(String subjectStatus) {
        this.subjectStatus = subjectStatus;
    }
}

main:

public class ObserverMain extends BasicExample {

    @Override
    public void startDemo() {
        ISubject huhanshang = new Boss();
        Observer maweidong = ObserverFactory.Factory("NBALooker", "maweidong", huhanshang);
        Observer zhangdashang = ObserverFactory.Factory("StockLooker", "zhangdashang", huhanshang);

        huhanshang.Attach(maweidong);
        huhanshang.Attach(zhangdashang);

        huhanshang.setSubjectStatus("I am back! Huhan Shang!");
        huhanshang.Broadcast();
    }

}
时间: 2024-09-30 20:55:37

设计模式11---观察者模式的相关文章

设计模式(16) 观察者模式(OBSERVER)C++实现

意图: 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新. 动机: 将一个系统设计成一系列相互协作的类有一个常见的副作用:需要维护相关对象之间的一致性. 观察者模式定义一种交互,即发布-订阅: 一个对象当自身状态发生改变时,会发出通知,但是并不知道谁是他的接收者,但每个接收者都会接收到通知,这些接受者称为观察者. 作为对通知的响应,每个观察者都将查询目标状态,然后改变自身的状态以和目标状态进行同步. 使用场景: 使对象封装为独立的改变和使用:

大话设计模式_观察者模式(Java代码)

观察者模式:定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象.这个主题对象在状态发生变化时,会通知所有观察者对象,使他们自己能够自动更新自己.简单描述:1个Subject类(可以是抽象类可以是接口),可以有多个具体Subject类(继承抽象Subject),此具体Subject持有多个观察者的引用,在此具体Subject状态发生变化的时候调用这些观察者的相应方法.另外,这些持有的引用是抽象的,不是具体的,而这些引用所指向的对象时具体的观察者(即需要作出更新的具体观察者,这些具体

常用设计模式之观察者模式 + 事件委托

常用设计模式之观察者模式 + 事件委托 作用及UML (摘自<大话设计模式>) Code 1 abstract class Subject{ 2 protected String state; 3 public void setState(String state){this.state = state;} 4 public String getState(){return this.state;} 5 6 private List<Observer> observers = ne

设计模式 11 —— 代理模式

设计模式目录: 设计模式 1 ——观察者模式 设计模式 2 —— 装饰者模式 设计模式 3 —— 迭代器和组合模式(迭代器) 设计模式 4 —— 迭代器和组合模式(组合) 设计模式 5 —— 工厂模式 设计模式 6 —— 单件模式 设计模式 7 —— 命令模式 设计模式 8 —— 适配器和外观模式 设计模式 9 —— 模板方法模式 设计模式 10 —— 状态模式 设计模式 11 —— 代理模式 概述 一 代理模式基本概念 二 参考 一 代理模式基本概念 代理模式为另一个对象提供一个替身或占位符以

设计模式之观察者模式(Observer)摘录

23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于如何创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而一个对象创建型模式将实例化委托给另一个对象.创建型模式有两个不断出现的主旋律.第一,它们都将关于该系统使用哪些具体的类的信息封装起来.第二,它们隐藏了这些类的实例是如何被创建和放在一起的.整个系统关于这些对象所知道的是由抽象类所定义的接口.因此,创建型模式在什么被创建,谁创建它,它是怎样被创建的,以

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

设计模式目录: 设计模式 1 ——观察者模式 一.基本定义 何谓观察者模式?观察者模式定义了对象之间的一对多依赖关系,这样一来,当一个对象改变状态时,它的所有依赖者都会收到通知并且自动更新. 在这里,发生改变的对象称之为观察目标,而被通知的对象称之为观察者.一个观察目标可以对应多个观察者,而且这些观察者之间没有相互联系,所以么可以根据需要增加和删除观察者,使得系统更易于扩展. 观察者模式又称为发布-订阅模式. 二.基本结构 首先先看观察者模式的UML类图. 分析: Subject:目标.他把所有

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

原文:C#设计模式(17)--观察者模式(Observer Pattern) 一.引言 在现实生活中,处处可见观察者模式,例如,微信中的订阅号,订阅博客和QQ微博中关注好友,这些都属于观察者模式的应用.在这一章将分享我对观察者模式的理解,废话不多说了,直接进入今天的主题. 二. 观察者模式的介绍 2.1 观察者模式的定义 从生活中的例子可以看出,只要对订阅号进行关注的客户端,如果订阅号有什么更新,就会直接推送给订阅了的用户.从中,我们就可以得出观察者模式的定义. 观察者模式定义了一种一对多的依赖

【设计模式】观察者模式

生活中,当某件事发生时,应该通知所有的相关者.例如,上课地点有变,要通知所有学习这门课的同学. 在软件设计中,当一个对象的状态发生变化是,如何通知与它相关的所有对象,就是我们今天要谈到的观察者模式. 观察者模式 概述 定义了一种一对多的依赖关系.让多个观察者对象同事监听某一个主题对象.这个主题对象在状态发生变化时,会通知所有的观察者对象,使它们能够自动更新自己. 实际上,观察者模式所做的工作就是在解除耦合.让耦合的双方都依赖于抽象,而不是依赖于具体.从而使得各自的变化都不会影响另一边的变化. 结

设计模式:观察者模式

设计模式:观察者模式 : http://www.cnblogs.com/li-peng/archive/2013/02/04/2892116.html 观察者模式是我们经常用的一个模式,比如在用wcf做服务的时候通知客户端做一些操作一般用设计者模式. 今天做一个订报纸的小例子来理解一下观察者模式  出版者+订阅者=观察者模式 用下边的图来说就是    人民日报+订阅者=观察者模式 只要是订阅了人民日报的人,有了新报纸就会送到订阅者那里去, 当你不想订的时候取消就不订阅就不会再收到报纸了. //报

设计模式之-观察者模式

该文代码来自设计模式之惮一书. 观察者模式定义: 观察者模式也叫做发布订阅模式. 观察者模式中的角色: 1.被观察者 被观察者职责为管理观察者并通知观察者. 2.观察者 对接受到的消息进行处理. /// <summary> /// 被观察者 /// </summary> public abstract class Subject { /// <summary> /// 观察者集合 /// </summary> private List<IObserva