【设计模式】组件协作模式（模板方法/策略模式/观察者模式）

最新推荐文章于 2024-05-26 17:27:43 发布
最新推荐文章于 2024-05-26 17:27:43 发布
阅读量137 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 多态 设计模式 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moX980/article/details/116487980
版权

组件协作模式

现代软件：框架与应用的划分

组件协作主要通过晚绑定来实现松耦合

  • template method模板方法
  • strategy策略模式
  • observer/event观察者模式

1.模板方法template method

样板

动机：软件构件过程中对于某一项特定的任务常常有稳定的整体结构，但各个子步骤却有很多变化，先实现谁呢？如何在确定的整体结构的前提下来灵活应对各个子步骤的变化或晚期实现需求呢？

//程序库开发人员
class Library{

public:
	void Step1(){
		//...
	}

    void Step3(){
		//...
    }

    void Step5(){
		//...
    }
};

//应用程序开发人员
class Application{
public:
	bool Step2(){
		//...
    }

    void Step4(){
		//...
    }
};

int main()
{
	Library lib();
	Application app();

	lib.Step1();

	if (app.Step2()){
		lib.Step3();
	}

	for (int i = 0; i < 4; i++){
		app.Step4();
	}

	lib.Step5();

}

//程序库开发人员
class Library{
public:
	//稳定 template method
    void Run(){
        
        Step1();

        if (Step2()) { //支持变化 ==> 虚函数的多态调用
            Step3(); 
        }

        for (int i = 0; i < 4; i++){
            Step4(); //支持变化 ==> 虚函数的多态调用
        }

        Step5();

    }
	virtual ~Library(){ }//有继承关系的基类的析构是虚函数 

protected:
	
	void Step1() { //稳定
        //.....
    }
	void Step3() {//稳定
        //.....
    }
	void Step5() { //稳定
		//.....
	}

	virtual bool Step2() = 0;//变化
    virtual void Step4() =0; //变化
};

//应用程序开发人员
class Application : public Library {
protected:
	virtual bool Step2(){
		//... 子类重写实现
    }

    virtual void Step4() {
		//... 子类重写实现
    }
};




int main()
	{
	    Library* pLib=new Application();
	    lib->Run();

		delete pLib;
	}
}

结构化软件设计流程

image-20210506141352307

面向对象软件设计流程

image-20210506141517705

image-20210506141700151

一个晚的东西调用早的东西——早绑定

一个早的东西调用晚的东西——晚绑定

模式定义：

定义一个操作中的算法的骨架（稳定），而将 一些步骤延迟（变化）到子类中。template method 使得子类可以不改变（复用）一个算法的结构即可重定义（override重写）该算法的某些特定步骤

  • 稳定的写为正常函数
  • 变化的要写为虚函数

设计模式的前提必须有稳定点

将小兔子放在笼子里让它活动，不能让它跳出来污染整个房子——设计模式！！！

image-20210506142941910

红色的为稳定部分，蓝色的为变化的部分

要点总结：

  1. 非常基础性，常用，它用最简洁的机制（虚函数的多态）为很多应用程序框架提供了灵活的扩展点，是代码复用方面的基本实现结构 继承+虚函数多态就是扩展
  2. 反向控制结构 不要调用我，让我来调用你
  3. 被template method调用的虚方法可以实现 也可以不实现 但一般设置为protected

2.策略模式strategy

动机： 在软件构建过程中，某些对象使用的算法可能是多种多样的，经常改变，如果将这些算法都编码到对象中，将会使对象变得很发杂，而且有时候支持不使用的算法也是一个性能负担。

如何在运行时根据需要透明的改变对象的算法？将算法与对象本身解耦，从而避免上述问题？

//计算税
enum TaxBase {
	CN_Tax,
	US_Tax,
	DE_Tax,
	FR_Tax       //更改 
};

class SalesOrder{
    TaxBase tax;
public:
    double CalculateTax(){
        //...
        
        if (tax == CN_Tax){
            //CN***********
        }
        else if (tax == US_Tax){
            //US***********
        }
        else if (tax == DE_Tax){
            //DE***********
        }
		else if (tax == FR_Tax){  //更改 违背开放封闭原则
			//...
		}

        //....
     }
    
};


class TaxStrategy{
public:
    virtual double Calculate(const Context& context)=0;
    virtual ~TaxStrategy(){}
};


class CNTax : public TaxStrategy{
public:
    virtual double Calculate(const Context& context){
        //***********
    }
};

class USTax : public TaxStrategy{
public:
    virtual double Calculate(const Context& context){
        //***********
    }
};

class DETax : public TaxStrategy{
public:
    virtual double Calculate(const Context& context){
        //***********
    }
};



//扩展
//*********************************
class FRTax : public TaxStrategy{
public:
	virtual double Calculate(const Context& context){
		//.........
	}
};


class SalesOrder{
private:
    TaxStrategy* strategy;//实现多态的变量一般用指针

public:
    //工厂模式
    SalesOrder(StrategyFactory* strategyFactory){
        this->strategy = strategyFactory->NewStrategy();
    }
    ~SalesOrder(){
        delete this->strategy;
    }

    public double CalculateTax(){
        //...
        Context context();
        
        double val = 
            strategy->Calculate(context); //多态调用
        //...
    }
    
};

模式定义： 定义一系列算法，把它们一个个封装起来，并且使他们可以互相替换（变化）。该模式使得算法可独立于它的客户程序（稳定）而变化（扩展，子类化）

image-20210506161608839

要点总结：

  1. strategy及其子类提供了一系列可重用算法 使得类型在运行时方便的根据需要在各个算法切换
  2. 当if-elseif-else出现时，常常标志着strategy策略的出现，strategy策略模式提供了另一种if-else实现方式 但是当if-else是稳定的（一周7天）就用if-else就好
  3. 如果strategy对象没有实例变量，那么各个上下文可以共享同一个strategy对象从而节省对象开支

3.观察者模式observer/event

动机： 需要为某些对象建立一种“通知依赖关系”——一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知。如果这样的依赖关系过于紧密，将使得软件不能很好的抵御变化。

使用面向对象技术，可以将这种依赖关系弱化，并形成一种稳定的依赖关系从而实现软件体系结构的松耦合

文件分割器：上古时代软盘copy大文件

//界面
class MainForm : public Form
{
	TextBox* txtFilePath;
	TextBox* txtFileNumber;
    
	ProgressBar* progressBar;//改变 编译时依赖 实现细节 以后的进度条可能是另外的形式 界面依赖于进度条（实现细节）
    //通知 

public:
	void Button1_Click(){

		string filePath = txtFilePath->getText();
		int number = atoi(txtFileNumber->getText().c_str());

		FileSplitter splitter(filePath, number, progressBar);//改变

		splitter.split();

	}
};

//分割功能
class FileSplitter
{
	string m_filePath;
	int m_fileNumber;
	ProgressBar* m_progressBar;//改变

public:
	FileSplitter(const string& filePath, int fileNumber, ProgressBar* progressBar) :
		m_filePath(filePath), 
		m_fileNumber(fileNumber),
		m_progressBar(progressBar){//改变

	}

	void split(){

		//1.读取大文件

		//2.分批次向小文件中写入
		for (int i = 0; i < m_fileNumber; i++){
			//...
            //改变
			float progressValue = m_fileNumber;
			progressValue = (i + 1) / progressValue;
			m_progressBar->setValue(progressValue);
		}

	}
};

//提出新需求 文件分割进度条
//违背依赖倒置原则
//

//界面
class MainForm : public Form, public IProgress //c++多继承不推荐用 可能带来复杂耦合性问题 推荐一种多继承 一个主继承类 其他的为接口类
{
	TextBox* txtFilePath;
	TextBox* txtFileNumber;
	ProgressBar* progressBar;

public:
	void Button1_Click(){

		string filePath = txtFilePath->getText();
		int number = atoi(txtFileNumber->getText().c_str());

		FileSplitter splitter(filePath, number, progressBar, this);

		splitter.split();

	}
	virtual void doProgress(float value){
		progressBar->setValue(value);
	}
};

//文件分割部分
class IProgress{
publuc:
	virtual void doProgress(float value) = 0;
	virtual ~IProgress(){}
};

//整个文件分割类不依赖于任何界面元素 可以放在任何系统中使用
class FileSplitter
{
	string m_filePath;
	int m_fileNumber;
	//ProgressBar* m_progressBar;//通知控件
	IProgress* m_iprogress;//抽象通知机制

public:
	FileSplitter(const string& filePath, int fileNumber, IProgress* iprogress) :
		m_filePath(filePath), 
		m_fileNumber(fileNumber),
		m_iprogress(iprogress)){

	}

	void split(){

		//1.读取大文件

		//2.分批次向小文件中写入
		for (int i = 0; i < m_fileNumber; i++){
			//...
			// float progressValue = m_fileNumber;
			// progressValue = (i + 1) / progressValue;
			// m_progressBar->setValue(progressValue);
			if(m_iprogress != nullptr){
				float progressValue = m_fileNumber;
				progressValue = (i + 1) / progressValue;
				m_iprogress->doProgress(progressValue);//更新进度条
			}
		}

	}
};

//问题 如果要支持多个通知该怎么办 支持多个观察者

class MainForm : public Form, public IProgress //c++多继承不推荐用 可能带来复杂耦合性问题 推荐一种多继承 一个主继承类 其他的为接口类
{
	TextBox* txtFilePath;
	TextBox* txtFileNumber;
	ProgressBar* progressBar;

public:
	void Button1_Click(){

		string filePath = txtFilePath->getText();
		int number = atoi(txtFileNumber->getText().c_str());
		ConsoleNotifier cn;
		FileSplitter splitter(filePath, number, progressBar);
		//支持多个观察者
        splitter.addIProgress(this);//订阅通知
		splitter.addIProgress(&cn);//订阅通知
		splitter.split();

	}
	virtual void doProgress(float value){
		progressBar->setValue(value);
	}
};
//另一个观察者
class ConsoleNotifier : public IProgress{
public:
	virtual void DoProgress(float value){
		cout << value << endl;
	}
};

class IProgress{
publuc:
	virtual void doProgress(float value) = 0;
	virtual ~IProgress(){}
};

//整个文件分割类不依赖于任何界面元素 可以放在任何系统中使用
class FileSplitter
{
	string m_filePath;
	int m_fileNumber;
	//ProgressBar* m_progressBar;//通知控件
	List<IProgress*> m_iprogressList;//抽象通知机制 最大的重点 支持多个观察者

public:
	FileSplitter(const string& filePath, int fileNumber) :
		m_filePath(filePath), 
		m_fileNumber(fileNumber))){

	}
	void addIProgress(IProgress* iprogress){
		m_iprogressList.add(iprogress);
	}
	void removeIProgress(IProgress* iprogress){
		m_iprogressList.remove(iprogress);
	}
	void split(){

		//1.读取大文件

		//2.分批次向小文件中写入
		for (int i = 0; i < m_fileNumber; i++){
			//...
			// float progressValue = m_fileNumber;
			// progressValue = (i + 1) / progressValue;
			// m_progressBar->setValue(progressValue);
			float progressValue = m_fileNumber;
			progressValue = (i + 1) / progressValue;
			onProgress(progressValue);
		}

	}
protected:
	void onProgress(float value){
		for(auto iter = m_iprogressList.begin(); iter != m_iprogressList.end(); iter++)
			(*iter)->doProgress(value);//多个观察者更新通知
		}
	}
};

模式定义：定义对象的一种一对多（变化）的依赖关系，以便当一个对象的状态发生改变时，所有依赖于它的对象（subject）都能得到通知并自动更新

image-20210507110702580

observer——Iprogress

ConcreteObserver——Mainform/ConSoleNotifier

Subject/ConcreteSubject——filesplitter（没有将对象抽象）

要点总结：

  1. 使用观察者模式使得我们可以独立地改变目标与观察者，从而使两者之间的依赖关系称为松耦合（随便添加多少个观察者都行，对象的结构是稳定的）
  2. 目标发送通知时无需指定观察者，通知自动传播（onProgress）
  3. 观察者自己决定是否需要订阅通知，目标对象对此一无所知
  4. Observer模式是基于时间的UI框架中非常常用的设计模式，也是MVC模式重要的组成部分
沙diao网友
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【设计模式】组件模式——Strategy（ToDo）
qq_28011221的博客
08-09 229
目录 一、动机Motivation 二、实例 三、模式定义 四、结构 五、要点总结 一、动机Motivation 如何在运行时根据需要透明地更改对象的算法？将算法与对象本身解耦，从而避免了以下问题： 在软件构建过程中，某些对象使用的算法可能多种多样，经常改变，如果将这些算法都编码到对象中，将会使对象变得异常复杂，而且有时候支持不使用的算法...
【设计模式】组件模式——Template Method
qq_28011221的博客
08-09 531
一、组件协作模式 现代软件专业分工之后的第一个结果是“框架与应用程序划分”。而“组件协作”是通过晚期绑定来实现框架与应用程序的松耦合，是二者之间协作时常用的模式。 组件模式包括： 1、Template Method 2、Str...
设计模式-组件模式
m0_51810668的博客
04-30 151
组件模式：一个东西，既可以作为其他容器中的一项，同时自己也可以作为容器存储其他东西，其他东西可以是普通的内容，内容不能作为容器了，也可以是容器，而这个东西就是抽象的最上层。
C++设计模式之单例模式、模板模式、状态模式、原型模式、CRTP 模式、组件模式、观察者模式、发布-订阅模式、访问者模式
最新发布
喜欢打篮球的普通人
05-26 518
文章目录参考 参考 游戏开发中经常用到的设计模式 【C++】游戏开发常用的设计模式，高手都这样写？单例模式、组件模式、原型模式、访问者模式等
设计模式 组件模式
weixin_30478619的博客
11-08 199
先写一个抽象类，表示一部分 public abstract class Component { protected String name; public Component(String name) { this.name=name; } public abstract void Add(Component c); ...
组件设计模式
weixin_34297300的博客
09-27 437
作者：Jogis原文链接：https://github.com/yesvods/Bl... 转载请注明原文链接以及作者信息 在react生态圈里面，组件的设计非常自由。因为react本身只提供组件渲染以及生命周期，至于用户交互、数据交互、组件状态之间的关系，并没有强关联。 react组件设计模式分类 long long age，人们对组件...
吉林大学软件设计模式SDP03-02例子代码
11-08
在这个压缩包中，可能包含了多个不同的设计模式示例，比如单例模式（Singleton）、工厂模式（Factory）、观察者模式（Observer）、装饰器模式（Decorator）、策略模式（Strategy）等。下面将对这些常见的设计模式...
Java设计模式、设计原则、UML学习资料.zip
10-21
设计模式分为三大类：创建型模式（如单例、工厂方法、抽象工厂）、结构型模式（如适配器、桥接、装饰器、组合、外观、享元、代理）和行为型模式（如观察者、命令、解释器、迭代器、模板方法、访问者、状态、策略、...
设计模式 混搭 鸭子叫 Demo
04-29
在编程世界中，设计模式是解决常见问题的模板或最佳实践，它们被广泛应用于软件工程中以提高代码的可读性、可维护性和复用性。"设计模式 混搭 鸭子叫 Demo" 是一个具体的应用实例，旨在展示如何将多种设计模式巧妙地...
NETand-Design-Patterns.rar_NET与设计模式
09-21
设计模式分为三大类：创建型模式（如单例、工厂方法、抽象工厂等）、结构型模式（如代理、装饰器、适配器等）和行为型模式（如策略、观察者、迭代器等）。 在.NET开发中，单例模式是一种常见的创建型模式，确保一个...
计算机后端-Java-图解java设计模式代码.zip
05-23
**行为型设计模式**：这类模式关注对象之间的交互和职责分配，包括责任链模式（Chain of Responsibility）、命令模式（Command）、解释器模式（Interpreter）、迭代器模式（Iterator）、中介者模式（Mediator）、...
设计模式之组件协作模式
一颗哈士奇的博客
03-17 231
设计模式学习 设计模式的作用是 在稳定和变化之间寻找一个间隔层，将稳定部分和变化分割开，提高软件复用性。 一、软件设计思想 1.理解松耦合设计思想 2.掌握面向对象设计原则 3.掌握重构技法改善设计 4.掌握GOF 核心设计模式 二、设计原则 1.依赖倒置原则(DIP) 稳定（抽象） 依赖 稳定； 不稳定 （实现细节，易变化）依赖 稳定。 2.开放封闭原则（OCP） 对扩展开放，对更改封闭；就是增加一个需求时，只需要增加代码就好，而不是去修改以往代码。具有扩展性 3、单一职责原则 一个类只有一个责任 4.L
模版组件设计模式
feiwa18203593832的博客
09-15 516
目录 声明 模块 实例    题目   模版   组件   组件数据 代码展示   模版   组件   组件数据 联系我 声明 此设计模式是本人原创，可能会有缺陷不足，而且更适用于属性冗余的类使用，比如 游戏。 比如Minecraft，本人也是在编写Minecraft 模组的时候想的此模式。 因为要写Minecraft 模组，离不开注册ID、本地化ID和各种属性，初...
设计模式分类之“组件协作模式”
weixin_46339898的博客
10-23 142
组件协作模式 “组件协作”模式通过晚期绑定来实现框架与应用程序之间的松耦合，是二者协作时常用的模式。 Template Method（模板方法模式） ​ 定义一个骨架（稳定），而将一些特定步骤**延迟（变化）到子类，Template Method使得子类可以不改变（复用）一个算法的结构即可重定义（Override重写）**某些特定步骤。 总结： 将“早绑定”转化为了“晚绑定” 直观的看其实就是 “虚函数的多态使用” 注意：在有类的继承中时，应该尽可能的将析构函数写成虚函数样式，这样是为了避免析构掉不合
游戏设计模式阅读笔记13——解耦模式（组件模式）
林深藏却云门寺
03-14 1329
允许单一实体跨越多个领域而不会导致这些领域彼此耦合。
李建忠设计模式之“组件协作”模式
好记性不如烂笔头，记录学习，记录bug
09-26 355
现代软件专业分工之后的第一个结果是“框架和应用程序的划分"，"组件协作”模式通过晚期绑定，来实现框架与应用程序之间的松耦合，是二者之间协作时常用的模式。 典型模式：Template Method、Strategy、Observer/Event
java设计模式--组合模式
wittdong的博客
03-17 285
组合模式就是将对象组合成树状结构，主要由抽象组件类或者接口、组合组件以及叶子组件组成。 1. 抽象组件类（也可以用接口来实现） package demo.design.zuhe; //抽象组件类或接口 public abstract class  Component {     protected String name;     public Component(String s){
李建忠设计模式-组件协作模式-模板方法模式
chunchunlaila的博客
05-09 239
1.前言 现代软件专业分工后的第一个结果是“框架与应用程序的划分”、“组件协作”模式通过晚期绑定，来实现框架与程序之间的松耦合，是二者之间协作时常用的模式。 典型模式： Template Method Strategy Observer/Event 2.模板方法模式（Template Method） 1.动机 软件构建过程中，它常常有稳定的整体结构，但各个子步骤却有很多改变的需求或者由于固定的原因而无法和任务的整体结构同时实现。 如何确定稳定操作结构的前提下，来灵活应对各个子步骤的变化或者晚
设计模式详解：组件调用关系与Mediator模式应用
行为型模式则关注对象间的交互和责任分配，如观察者模式（Observer）、策略模式（Strategy）等。 UML（统一建模语言）作为面向对象设计的主要工具，能够有效地表达设计模式的意图和结构，从而促进团队成员之间的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

沙diao网友

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值