观察者模式

//事件队列const enentList={}//封装监听 const $on=function(eventName,callback){ if(!enentList[eventName]){ enentList[eventName]=[]; } enentList[eventName].push(callback); }//封装发布 const $emit=function(eventName,params){ if(enentList[eventName]){ var arr= enentList[eventName]; arr.forEach((cb)=>{ cb(params) }) } }//封装解绑 const $off=function(eventName,callback){ if(enentList[eventName]){ if(callback){ var index= enentList[eventName].indexOf(callback); enentList[eventName].splice(index,1); }else{ enentList[eventName].length=0; } } } //测试, function fn1(params){ console.log(111,params); } function fn2(params)

意图 定义对象间的一种一对多的依赖关系 ,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。 动机 一致性，松耦合 需要维护相关对象间的 一致性 。我们不希望为了维持一致性而使各类紧密耦合，因为这样降低了它们的可重用性。 比如：Excel中制作测试数据的折线图、饼状图和柱状图，以直观的表现出性能的变化。在实际操作时，我发现，如果我修改了一个数据，折线图、饼状图和柱状图就都发生了变换。 这一模式中的关键对象是目标(subject)和观察者(observer)。一个目标可以有任意数目的依赖它的观察者。一旦目标的状态发生改变 , 所有的观察者都得到通知。作为对这个通知的响应，每个观察者都将查询目标以使其状态与目标的状态同步。 这种交互也称为发布－订阅（publish-subscribe） 。目标是通知的发布者。它发出通知时并不需知道谁是它的观察者。可以有任意数目的观察者订阅并接收通知。 适用性 在以下任一情况下可以使用观察者模式 : 当一个抽象模型有两个方面 , 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。 当对一个对象的改变需要同时改变其它对象 , 而不知道具体有多少对象有待改变。 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之 , 你不希望这些对象是紧密耦合的。 结构 参与者 Subject

简介 观察者属于行为型模式的一种, 又叫发布-订阅模式. 如果一个对象的状态发生改变,依赖他的对象都将发生变化, 那么这种情况就适合使用观察者模式. 它包含两个术语,主题(Subject),观察者(Observer), 主题管理一个观察者的列表, 并在状态发生变化时通知到他们. 实现层面上, 主题定义了一个观察者列表并可以管理这个列表(将观察者注册进去和撤销注册的行为), 同时定义了通知到所有观察者的行为. Java类库有默认的观察者实现类 Observer . 使用观察者模式的还有事件监听, RxJava等. 意图 定义对象之间的一对多依赖，当一个对象状态改变时，它的所有依赖都会收到通知并且自动更新状态。 类图 实现 一. 定义抽象观察者 /** * 观察者抽象角色 */ public interface MyObserver { void update(Subject subject); } 二. 定义抽象主题 /** * 主题抽象角色 */ public abstract class Subject { private ArrayList<MyObserver> list = new ArrayList<MyObserver>(); public Subject register(MyObserver observer){ if(!list.contains(observer

　　观察者模式：在对象之间定义了一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象会收到通知并自动更新。简单的来说就是发布者发布信息，观察者收到信息后，做出反应。 　　观察者模式定义了对象间一对多的依赖关系，主要解决的是对象状态改变给其他对象通知的问题，同时还要易用性和低耦合度。 实现： 　　观察者模式使用三个类Subject、Observer和Client。 1、创建Subject类。 1 class Subject 2 { 3 private: 4 vector<Observer*> observers; 5 int state; 6 7 public: 8 9 void setState(int state) 10 { 11 //状态改变 12 this->state = state; 13 notifyAllObservers(); 14 } 15 16 void notifyAllObservers() 17 { 18 /* 19 vector<Observer*>::iterator ObsIter = observers.begin(); 20 //观察者做出响应 21 for (; ObsIter!=observers.end(); ++ObsIter) 22 { 23 (*ObsIter)->update(); 24 } 25 */ 26 for (auto

定义 定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 例：我们以新闻机构接收到新闻而后通知各个频道为例。那么新闻机构就是被观察对象，各个频道就是观察者。 实现方式 1、一般模式 ① 创建Subject类 public class Subject { private List<Observer> observers = new ArrayList<Observer>(); private int state; public int getState() { return state; } public void setState(int state) { this.state = state; notifyAllObservers(); } public void attach(Observer observer){ observers.add(observer); } public void notifyAllObservers(){ for (Observer observer : observers) { observer.update(); } } } ② 创建Observer类 public abstract class Observer { protected Subject subject; public

首先推荐一下别人写的，很不错可以参考，http://www.cnblogs.com/li-peng/archive/2013/02/04/2892116.html 1.定义 观察者模式：在对象之间定义一对多的依赖，当一个对象改变状态时，依赖它的对象都会收到通知并自动更新。 原则：为交互对象之间的松耦合设计而努力 2：使用场景 传统例子，订阅报纸，报纸为主题，订阅者为观察者，当报纸更新时，订阅者就会收到最新的报纸。 3：代码实现 ★主题（报纸的接口和实现），更新报纸，添加，删除，通知观察者 interface IPaper { void UpdatePaper(string Content); void RegisterObserver(IMan man); void RemoveObserver(IMan man); void NotifyObserver(string content); } public class PeoplePaper : IPaper { private List<IMan> manList; public void RegisterObserver(IMan man) { manList.Add(man); } public void RemoveObserver(IMan man) { if (manList.IndexOf(man) >= 0) {

观察者模式 　　定义：在对象间定义一种一对多的关系，以便在某对象发生改变时，与它存在依赖关系的所有对象都能收到通知并自动进行更新。 　　观察者模式的使用非常的广泛，我们熟知的MVC框架的底层就是观察者模式，java甚至直接把它集成到系统库中（java.util.Observer)，c#更是直接将它集成在了语言层面（event关键字）。 解锁成就系统 　　在现代的游戏中通常都会有一个成就系统，当你完成某个任务的时候，会解锁相应的成就。例如：“杀死100个恶魔”，“从桥上掉下”等。但要实现这么一个优雅的成就系统是比较棘手的，设想”从桥上掉下“这个任务，如果我们把它写在物理系统的碰撞检测中是可以工作的，但同时我们也引入了一个很强的耦合，这个耦合会让我们的代码显得丑陋而且不利于后期的更新和维护。这个时候我们就需要观察者模式了。 　　那观察者模式是如何工作的了？简单的来说，它就是发生变化的对象发送一个消息通知所有对这个消息感兴趣的对象，不用关心具体是谁，而接收这个消息的对象根据消息的内容自动更新自己。一段简陋但有效的代码可以说明这个情况： void Physics::updateEntity(Entity& entity) { bool wasOnSurface = entity.isOnSurface(); entity.accelerate(GRAVITY); entity.update

【1】什么是观察者模式？ 观察者模式，定义一种一对多的依赖关系，多个观察者对象同时监听某一个主题对象。 当这个主题对象状态上发生变化时，会通知所有观察者对象，他们能够自动更新自己，随主题对象状态改变做出对应的行为表现。 【2】观察者模式代码示例： 代码示例如下： 1 #include <iostream> 2 #include <string> 3 #include <list> 4 using namespace std; 5 6 class Observer; 7 8 // 管理观察者的基类 9 class Subject 10 { 11 public: 12 string action; // 主题名称 13 protected: 14 list<Observer*> observers; // 观察者的容器 15 16 public: 17 virtual void attach(Observer*) = 0; 18 virtual void detach(Observer*) = 0; 19 virtual void notify() = 0; 20 }; 21 22 // 观察者基类 23 class Observer 24 { 25 protected: 26 string name; 27 Subject *sub; 28 29 public: 30

什么是发布订阅模式(观察者模式)？ 定义： 定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 主要解决： 一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。 何时使用： 一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。 如何解决： 使用面向对象技术，可以将这种依赖关系弱化。 关键代码： 对于某一个topci用数组存放订阅者. 应用实例： 1、拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价。 2、西游记里面悟空请求菩萨降服红孩儿，菩萨洒了一地水招来一个老乌龟，这个乌龟就是观察者，他观察菩萨洒水这个动作。 优点： 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。 缺点： 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。 使用场景： 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。

观察者模式又叫做发布-订阅模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。 观察者模式所做的工作其实就是在解除耦合，让耦合的双方都依赖于抽象，而不是依赖于具体，从而使得各自的变化都不会影响另一边的变化。 代码如下： package xiao; import java.util.ArrayList; import java.util.List; interface Subject{ void Attach(Observer observer); void Detach(Observer observer); void Notify(); String getSubjectState(); void setSubjectState(String subjectState); } abstract class Observer{ protected String name; protected Secretary sub; public abstract void update(); } class Secretary implements Subject{ private List<Observer> observers = new ArrayList<Observer>();