网站备案要多少钱,英文淘宝网站建设,免费开源cms内容管理系统,网站与建设的字体间距1. 设计模式原理说明
观察者模式#xff08;Observer Pattern#xff09; 是一种行为设计模式#xff0c;它定义了一种一对多的依赖关系#xff0c;当一个对象的状态发生改变时#xff0c;所有依赖于它的对象都会得到通知并自动更新。这种模式非常适合处理事件驱动系统Observer Pattern 是一种行为设计模式它定义了一种一对多的依赖关系当一个对象的状态发生改变时所有依赖于它的对象都会得到通知并自动更新。这种模式非常适合处理事件驱动系统其中对象之间需要保持同步但又不想紧密耦合。
主要角色
Subject主题/被观察者它知道它的观察者是谁。任何数量的观察者都可以观察一个主题。提供注册和删除观察者对象的方法。Observer观察者为那些在主题发生改变时需获得通知的对象定义一个更新接口。ConcreteSubject具体主题将有关状态存储于具体观察者对象当它的状态发生改变时向它的各个观察者发出通知。ConcreteObserver具体观察者实现Observer的更新接口以使自身状态与主题的状态保持一致。
2. UML 类图及解释
UML 类图
------------------ -----------------------
| Subject | | Observer |
|------------------| |-----------------------|
| - observers: ListObserver | | - update(message: String): void |
| - register(observer: Observer) | -----------------------
| - unregister(observer: Observer) | |
| - notifyObservers(message: String) | |
------------------ -----------------------||v---------------------------| ConcreteObserverA ||--------------------------|| - update(message: String) |---------------------------^|---------------------------| ConcreteObserverB ||--------------------------|| - update(message: String) |---------------------------
类图解释
Subject定义了添加、删除和通知观察者的接口。具体主题会实现这些方法并维护一个观察者列表。Observer定义了一个更新接口当主题发生变化时观察者会被调用。ConcreteSubject实现了Subject接口当其状态变化时会通知所有已注册的观察者。ConcreteObserverA 和 ConcreteObserverB实现了Observer接口当收到主题的通知时会更新自己的状态。
3. 代码案例及逻辑详解
Java 代码案例
// 观察者接口
interface Observer {void update(String message);
}// 具体观察者A
class ConcreteObserverA implements Observer {Overridepublic void update(String message) {System.out.println(ConcreteObserverA received: message);}
}// 具体观察者B
class ConcreteObserverB implements Observer {Overridepublic void update(String message) {System.out.println(ConcreteObserverB received: message);}
}// 被观察者接口
interface Subject {void register(Observer observer);void unregister(Observer observer);void notifyObservers(String message);
}// 具体被观察者
class ConcreteSubject implements Subject {private ListObserver observers new ArrayList();Overridepublic void register(Observer observer) {observers.add(observer);}Overridepublic void unregister(Observer observer) {observers.remove(observer);}Overridepublic void notifyObservers(String message) {for (Observer observer : observers) {observer.update(message);}}public void changeState() {// 模拟状态变化System.out.println(State changed, notifying observers...);notifyObservers(State has been changed!);}
}// 客户端
public class Client {public static void main(String[] args) {ConcreteSubject subject new ConcreteSubject();Observer observerA new ConcreteObserverA();Observer observerB new ConcreteObserverB();subject.register(observerA);subject.register(observerB);subject.changeState();subject.unregister(observerA);subject.changeState();}
}
C 代码案例
#include iostream
#include vector
#include algorithm// 观察者接口
class Observer {
public:virtual void update(const std::string message) 0;virtual ~Observer() {}
};// 具体观察者A
class ConcreteObserverA : public Observer {
public:void update(const std::string message) override {std::cout ConcreteObserverA received: message std::endl;}
};// 具体观察者B
class ConcreteObserverB : public Observer {
public:void update(const std::string message) override {std::cout ConcreteObserverB received: message std::endl;}
};// 被观察者接口
class Subject {
private:std::vectorObserver* observers;
public:void registerObserver(Observer* observer) {observers.push_back(observer);}void unregisterObserver(Observer* observer) {observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());}void notifyObservers(const std::string message) {for (Observer* observer : observers) {observer-update(message);}}void changeState() {// 模拟状态变化std::cout State changed, notifying observers... std::endl;notifyObservers(State has been changed!);}
};// 客户端
int main() {Subject subject;Observer* observerA new ConcreteObserverA();Observer* observerB new ConcreteObserverB();subject.registerObserver(observerA);subject.registerObserver(observerB);subject.changeState();subject.unregisterObserver(observerA);subject.changeState();delete observerA;delete observerB;return 0;
}
Python 代码案例
# 观察者接口
class Observer:def update(self, message):raise NotImplementedError# 具体观察者A
class ConcreteObserverA(Observer):def update(self, message):print(fConcreteObserverA received: {message})# 具体观察者B
class ConcreteObserverB(Observer):def update(self, message):print(fConcreteObserverB received: {message})# 被观察者接口
class Subject:def __init__(self):self._observers []def register(self, observer):self._observers.append(observer)def unregister(self, observer):self._observers.remove(observer)def notify_observers(self, message):for observer in self._observers:observer.update(message)def change_state(self):# 模拟状态变化print(State changed, notifying observers...)self.notify_observers(State has been changed!)# 客户端
if __name__ __main__:subject Subject()observerA ConcreteObserverA()observerB ConcreteObserverB()subject.register(observerA)subject.register(observerB)subject.change_state()subject.unregister(observerA)subject.change_state()
Go 代码案例
package mainimport (fmt
)// 观察者接口
type Observer interface {update(message string)
}// 具体观察者A
type ConcreteObserverA struct{}func (c *ConcreteObserverA) update(message string) {fmt.Printf(ConcreteObserverA received: %s\n, message)
}// 具体观察者B
type ConcreteObserverB struct{}func (c *ConcreteObserverB) update(message string) {fmt.Printf(ConcreteObserverB received: %s\n, message)
}// 被观察者接口
type Subject struct {observers []Observer
}func (s *Subject) register(observer Observer) {s.observers append(s.observers, observer)
}func (s *Subject) unregister(observer Observer) {for i, obs : range s.observers {if obs observer {s.observers append(s.observers[:i], s.observers[i1:]...)break}}
}func (s *Subject) notifyObservers(message string) {for _, observer : range s.observers {observer.update(message)}
}func (s *Subject) changeState() {// 模拟状态变化fmt.Println(State changed, notifying observers...)s.notifyObservers(State has been changed!)
}// 客户端
func main() {subject : Subject{}observerA : ConcreteObserverA{}observerB : ConcreteObserverB{}subject.register(observerA)subject.register(observerB)subject.changeState()subject.unregister(observerA)subject.changeState()
}
4. 总结
观察者模式 是一种行为设计模式它定义了一种一对多的依赖关系当一个对象的状态发生改变时所有依赖于它的对象都会得到通知并自动更新。这种模式特别适用于事件驱动系统其中对象之间需要保持同步但又不想紧密耦合。
主要优点
松耦合观察者和被观察者之间的依赖关系非常松散观察者不需要知道被观察者的具体实现细节。支持广播通信被观察者可以向所有注册的观察者广播消息无需关心观察者的具体类型。灵活性高可以动态地添加或删除观察者而不会影响其他观察者。
主要缺点
过度通知如果被观察者的状态频繁变化可能会导致大量不必要的通知。复杂性增加引入观察者模式会增加系统的复杂性特别是当观察者和被观察者之间存在复杂的依赖关系时。调试困难由于观察者模式涉及多个对象之间的交互调试时可能比较困难。
适用场景
当一个对象的改变需要同时改变其他对象而且不知道具体有多少对象需要改变时。当一个对象需要在另一个对象的状态发生变化时自动更新但又不想紧密耦合时。当一个抽象模型有两个方面其中一个方面依赖于另一方面将这两者封装在独立的对象中以提高可复用性和灵活性时。
