当前位置： 首页 > news >正文

百度网站收录查询地址百度站长平台论坛

news 2026/4/7 20:35:57
百度网站收录查询地址,百度站长平台论坛,南山商城网站建设,b2b网站建设方案1. 设计模式原理说明 观察者模式（Observer Pattern） 是一种行为设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式非常适合处理事件驱动系统&a…

1. 设计模式原理说明

观察者模式（Observer Pattern） 是一种行为设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式非常适合处理事件驱动系统，其中对象之间需要保持同步但又不想紧密耦合。

主要角色
  1. Subject（主题/被观察者）：它知道它的观察者是谁。任何数量的观察者都可以观察一个主题。提供注册和删除观察者对象的方法。
  2. Observer（观察者）：为那些在主题发生改变时需获得通知的对象定义一个更新接口。
  3. ConcreteSubject（具体主题）：将有关状态存储于具体观察者对象；当它的状态发生改变时，向它的各个观察者发出通知。
  4. ConcreteObserver（具体观察者）：实现Observer的更新接口以使自身状态与主题的状态保持一致。

2. UML 类图及解释

UML 类图
+------------------+                +-----------------------+
|   Subject        |                |     Observer          |
|------------------|                |-----------------------|
| - observers: List<Observer> |     | - 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 List<Observer> 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::vector<Observer*> 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(f"ConcreteObserverA received: {message}")# 具体观察者B
class ConcreteObserverB(Observer):def update(self, message):print(f"ConcreteObserverB 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[i+1:]...)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. 总结

观察者模式 是一种行为设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式特别适用于事件驱动系统，其中对象之间需要保持同步但又不想紧密耦合。

主要优点
  1. 松耦合：观察者和被观察者之间的依赖关系非常松散，观察者不需要知道被观察者的具体实现细节。
  2. 支持广播通信：被观察者可以向所有注册的观察者广播消息，无需关心观察者的具体类型。
  3. 灵活性高：可以动态地添加或删除观察者，而不会影响其他观察者。
主要缺点
  1. 过度通知：如果被观察者的状态频繁变化，可能会导致大量不必要的通知。
  2. 复杂性增加：引入观察者模式会增加系统的复杂性，特别是当观察者和被观察者之间存在复杂的依赖关系时。
  3. 调试困难：由于观察者模式涉及多个对象之间的交互，调试时可能比较困难。
适用场景
  • 当一个对象的改变需要同时改变其他对象，而且不知道具体有多少对象需要改变时。
  • 当一个对象需要在另一个对象的状态发生变化时自动更新，但又不想紧密耦合时。
  • 当一个抽象模型有两个方面，其中一个方面依赖于另一方面，将这两者封装在独立的对象中以提高可复用性和灵活性时。
http://www.hkea.cn/news/451864/

相关文章：

  • 中国菲律宾历史战绩网站关键词优化工具
  • 西宁网站建设最好的公司哪家好优秀网站设计案例
  • 沧州做网站费用搜索引擎优化是做什么的
  • 社区网站推广方案线上运营的5个步骤
  • 湘潭学校网站建设 z磐石网络网站关键词优化教程
  • wordpress多程序用户同步汕头seo排名
  • 旅游网站 建设平台分析百度seo一本通
  • 怎么用dw做网站app开发网站
  • 昆山做网站的公司有哪些seo整站优化推广
  • 网站建设谈单情景对话青岛seo百科
  • 网站做自适应好不好网页分析报告案例
  • 大连手机自适应网站建设公司seo诊断站长
  • 有哪些好的网站十大电商代运营公司
  • 个人网页设计欣赏网站整站优化快速排名
  • 多少钱立案seo 公司
  • 医学类的网站做Google百度怎么优化排名
  • 手机网站怎样做枸橼酸西地那非片的功效与作用
  • 邯郸做wap网站的公司六六seo基础运营第三讲
  • 六安市建设银行网站seo编辑的工作内容
  • seo外包平台福州百度快照优化
  • 橙子建站广告怎么投放竞价网络推广
  • 中国公司查询网站网络公司起名
  • wordpress邮箱内容更改一键关键词优化
  • 楼市最新消息2022年房价走势seo网络推广经理
  • wordpress免费中文企业主题seo权重优化软件
  • 周口网站建设哪家好济南专业seo推广公司
  • 济南网站忧化怎么把抖音关键词做上去
  • 网站建设与维护的题目网站点击软件排名
  • 网站收录服务企业网络的组网方案
  • nba排名灰色词seo排名