一,原理
观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个对象。这个对象在状态发生变化时,会通知所有观察者对象,使它们能够自动更新自己。
二,解决的问题
将一个系统分成一系列相互协作的类有一个很不好的副作用,就是这些类紧密耦合在一起,这为后期的扩展与维护都带来很大的不方便。观察者模式的关键,就是可以保持对象的独立性,解除对象之间的耦合,使原来具有依赖关系的对象依赖于抽象,而不是依赖于具体的类对象。
三,何时使用观察者模式
当一个对象的改变时,需要改变其他的对象,并且它不知道具体要改变多少对象。
四,模式中的角色
1,抽象主题(Subject):它把所有观察者对象的引用保存到一个集合里,每个主题都可以有任何数量的观察者。抽象主题提供一个接口,可以增加和删除观察者对象。
2,具体主题(ConcreteSubject):将有关状态存入具体观主题对象,当具体主题的状态改变时,给所有登记过的观察者发出通知。
3,抽象观察者(Observer):为所有的具体观察者定义一个接口,在得到主题通知时更新自己。
4,具体观察者(ConcreteObserver):实现抽象观察者角色所要求的更新接口,以便使本身的状态与主题状态协调。
五,应用实例
#include <iostream>
#include <vector>
#include <string>
using namespace std;
class Observer{
public:
virtual void Update(){}
};
class Subject{
private:
vector<Observer *> observers;
public:
//增加观察者
void Add(Observer *p){
observers.push_back(p);
}
//移除观察者
void Remove(Observer *p){
for(vector<Observer *>::iterator iter = observers.begin(); iter != observers.end(); iter ++){
if(p == *iter){
observers.erase(iter);
break;
}
}
}
//通知
void Notify(){
for(vector<Observer *>::iterator iter = observers.begin(); iter != observers.end(); iter ++){
(*iter)->Update();
}
}
};
class ConcreteSubject : public Subject{
private:
string state;
public:
string getState(){
return state;
}
void setSatate(const string &str){
state = str;
}
};
class ConcreteObserver : public Observer{
private:
string name;
string observerState;
ConcreteSubject &subject;
public:
ConcreteObserver(ConcreteSubject &subject, const string &name):subject(subject), name(name){}
void Update(){
observerState = subject.getState();
cout<<"观察者 : "<<name<<" 的状态是 : "<<observerState<<endl;
}
};
int main(){
ConcreteSubject s;
s.Add(new ConcreteObserver(s, "1"));
s.Add(new ConcreteObserver(s, "2"));
s.setSatate("sleep");
s.Notify();
s.setSatate("wake");
s.Notify();
return 0;
}
输出结果
观察者 : 1 的状态是 : sleep
观察者 : 2 的状态是 : sleep
观察者 : 1 的状态是 : wake
观察者 : 2 的状态是 : wake
Process returned 0 (0x0) execution time : 0.009 s
Press any key to continue.