【设计模式】状态模式、责任链模式、迭代器模式、解释器模式

最新推荐文章于 2023-11-25 19:15:50 发布
最新推荐文章于 2023-11-25 19:15:50 发布
阅读量284 收藏
点赞数
文章标签： 设计模式 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SWELER/article/details/128748790
版权
本文介绍了四种设计模式：状态模式用于管理对象在不同状态下的行为，通过封装转换规则，使得状态变化易于维护；责任链模式将请求的发送与接收解耦，形成链式处理；迭代器模式提供遍历集合元素的统一方式，不暴露内部结构；解释器模式用于构建语言解释器，定义文法并解释执行。这些模式提高了代码的灵活性和可扩展性。
摘要由CSDN通过智能技术生成

1、状态模式

简介

事物在不同的状态下会产生不同的动作，也会从一个状态转换到另一个状态。

当状态数目不多时可以用switch/case解决，但是当状态数目很多时维护很大一组switch/case将变得困难。

将状态逻辑和动作实现分离，而不是直接将状态的代码写在动作逻辑中，以便更好的进行扩展和维护。

优点：

  • 封装了转换规则。
  • 枚举可能的状态，在枚举状态之前需要确定状态种类。
  • 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。
  • 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。
  • 可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。

角色

  • 一个抽象的状态类，提供统一的接口
  • 若干个具体的状态，根据自己代表的状态重写父类的接口，拥有一个活动类的指针
  • 一个活动类，拥有所有的具体状态的指针，和一个当前状态的指针，拥有和状态类对应的操作接口，在调用操作接口时调用当前状态的操作接口

代码实现

模拟机器状态变化的过程。假设一个机器有三种状态，分别是正常、出错、维修中，我定义了这三种状态，活动类中有一个m_count计数器，假设这是机器的可靠指数，每次运行时消耗可靠指数，当可靠指数小于0时进入出错状态，出错状态不能运行，需要进行维修，然后进入维修状态，在维修状态运行时会再次出错，需要再次维修，则可靠指数加2，进入正常状态。

#include<iostream>
using namespace std;

class State{
public:
	virtual void ErrorHappened()=0;
	virtual bool Fix()=0;
	virtual bool Run()=0;
	virtual void show()=0;
};

class Activity;

class Normal : public State{
public:
	Normal(Activity * activity);
	void ErrorHappened();
	bool Fix();
	bool Run();
	void show();
private:
	Activity *m_activity;
};

class Error:public State{
public:	
	Error(Activity * activity);
	void ErrorHappened();
	bool Fix();
	bool Run();
	void show();

private:
	Activity *m_activity;
};

class Fixing:public State{
public:
	Fixing(Activity * activity);
	void ErrorHappened();
	bool Fix();
	bool Run();
	void show();
private:
	Activity *m_activity;
};


class Activity{
public:
	State* getState() const{
		return m_state;
	}
	void SetState(State* const state){
		m_state=state;
	}
	int getCount(){
		return m_count--;
	}
	void setCount(const int count){
		m_count=count;
	}
	State* getNormal() const{
		return m_normal;
	}
	void setNormal(State* const normal){
		m_normal=normal;
	}
	State* getError() const{
		return m_error;
	}
	void setError(State* const error){
		m_error=error;
	}
	State* getFixing()const{
		return m_fixing; 
	}
	Activity(int count){
		m_count=count;
		m_error=new Error(this);
		m_normal=new Normal(this);
		m_fixing=new Fixing(this);
		m_state=getNormal();

	}
	void ErrorHappened(){
		m_state->ErrorHappened();
	}
	void Fix(){
		m_count+=2;
		m_state->Fix();
	}
	void Run(){
		if(m_count>0)
			m_count--;
		if(m_count<=0){
			cout<<"Low avialibality "<<endl;
			m_state->ErrorHappened();
			return;
		}
		m_state->Run();

	}
	void show(){
		m_state->show();
	}
private:
	State* m_state;
	int m_count;
	State* m_error;
	State* m_fixing;
	State* m_normal;
};

Normal::Normal(Activity * activity){
	m_activity=activity;
}
void Normal::ErrorHappened(){
	m_activity->SetState(m_activity->getError());
}
bool Normal::Fix(){
	cout<<"No need to fix"<<endl;
	return false;
}
bool Normal::Run(){
	cout<<"Run successfully"<<endl;
	return true;
}
void Normal::show(){
	cout<<"Normal"<<endl;
}

Error::Error(Activity * activity){
	m_activity=activity;
}
void Error::ErrorHappened(){
	cout<<"Already Error"<<endl;
}
bool Error::Fix(){
	m_activity->SetState(m_activity->getFixing());
	return true;
}
bool Error::Run(){
	cout<<"Can't run"<<endl;
	return false;
}
void Error::show(){
	cout<<"Error"<<endl;
}

Fixing::Fixing(Activity* activity){
	m_activity=activity;
}
void Fixing::ErrorHappened(){
	m_activity->SetState(m_activity->getError());
}
bool Fixing::Fix(){
	m_activity->SetState(m_activity->getNormal());
	return true;
}
bool Fixing::Run(){
	cout<<"Can't run"<<endl;
	return false;
}
void Fixing::show(){
	cout<<"Fixing"<<endl;
}


int main(){
	Activity* ac=new Activity(1);
	for(int i=0;;i++){
		 cout<<"time: "<<i<<" state:";
		 ac->show();
		 cout<<endl;
		 cout<<"Input 1.Run   2.Fix  "<<endl;
		 int j=0;
		 cin>>j;
		 if(j==1){
		 	ac->Run();
		 }else if(j==2){
		 	ac->Fix();
		 }else{
		 	cout<<"Wrong operation"<<endl;
		 }

	}
	return 0;
}

2、责任链模式

简介

责任链模式为请求创建了一个接收者对象的链。每个接受者都含有另一个接收者的引用，如果一个接收者不能处理他的请求，就会把这个请求发送给他的下一个接受者了，以此类推。

客户只需要将请求发送到责任链上就可以了，不必关心请求处理的细节和请求的传递过程，实现了请求的发送者和请求的处理者解耦。

优点：

  • 将请求和处理分开，实现解耦，提高系统的灵活性
  • 简化了对象，使对象不需要知道链的结构
  • 调试不方便。采用了类似递归的方式，调试时逻辑可能比较复杂
  • 最佳应用场景：有多个对象可以处理同一个请求时，比如：多级请求、请假/加薪等审批流程、Java Web中Tomcat对Encoding的处理、拦截器

请添加图片描述

角色

  • 一个请求类，包含了请求的各种信息
  • 一个抽象的请求接收者类，拥有一个其他接收者的引用，一个处理请求的接口
  • 若干个不同类型的具体的请求接收者类，重写处理请求的接口

代码实现

模拟公司采购审批的过程。先定义一个采购请求类，包含了采购的金额，再定义一系列有顺序的审批员R1R2R3R4,按照各自的审批金额限制处理采购请求，如前一个不能审批，则传递给下一个审批员。

#include<iostream>
using namespace std;

class Purchase{
public:
	int getType()const{
		return type;
	}
	float getPrice()const{
		return price;
	}
	int getId()const{
		return id;
	}
	Purchase(const int type,const float price,const int id):
	type(type),price(price),id(id){}
private:
	int type;
	float price=0.f;
	int id=0;
};

class Approver{
public:
	void setApprover(Approver* approval){
		this->approval=approval;
	}
	explicit Approver(const string& name):name(name){
	}
	virtual void processRequest(Purchase* purchase)=0;
	string name;
	Approver* approval;
};

class R1:public Approver{
public:
	explicit R1(const string name):Approver(name){}
	void processRequest(Purchase* purchase){
		if(purchase->getPrice()<=5000){
			cout<<"id: "<<purchase->getId()<<
			" are dealed by "<<this->name<<" rank R1"<<endl;
		}else{
			approval->processRequest(purchase);
		}
	}
};

class R2:public Approver{
public:
	explicit R2(const string name):Approver(name){}
	void processRequest(Purchase* purchase){
		if(purchase->getPrice()>5000&&purchase->getPrice()<10000){
			cout<<"id: "<<purchase->getId()<<
			" are dealed by "<<this->name<<" rank R2"<<endl;
		}else{
			approval->processRequest(purchase);
		}
	}
};

class R3:public Approver{
public:
	explicit R3(const string name):Approver(name){}
	void processRequest(Purchase* purchase){
		if(purchase->getPrice()<=10000&&purchase->getPrice()<50000){
			cout<<"id: "<<purchase->getId()<<
			" are dealed by "<<this->name<<" rank R3"<<endl;
		}else{
			approval->processRequest(purchase);
		}
	}
};

class R4:public Approver{
public:
	explicit R4(const string name):Approver(name){}
	void processRequest(Purchase* purchase){
		
		cout<<"id: "<<purchase->getId()<<
		" are dealed by "<<this->name<<" rank R4"<<endl;
		
	}
};

int main(){
	Purchase * p=new Purchase(1,100000,1);
	Approver* r1=new R1("jack");
	Approver* r2=new R2("bob");
	Approver* r3=new R3("dask");
	Approver* r4=new R4("ammb");
	r1->setApprover(r2);
	r2->setApprover(r3);
	r3->setApprover(r4);
	r1->processRequest(p);
	return 0;

}

3、迭代器模式

简介

迭代器模式提供一种遍历集合中所有对象的统一的方式，不需要知道集合对象的底层表示，即不暴露其内部结构。

角色

  • 一个抽象的迭代器类，提供返回第一个、返回下一个、返回当前元素、是否遍历完毕等接口。
  • 一个具体的迭代器类，拥有一个某种数据结构的指针和该数据结构的元素个数。
  • 一个抽象的数据结构类，声明了增加、删除元素、创建迭代器、返回数量等接口。
  • 一个具体的数据结构类，封装原始的数据结构，拥有一个对应的迭代器指针。

代码实现

介绍同上，在需要遍历数据结构的元素时使用该封装过的数据结构里的迭代器进行遍历。

#include<iostream>
#include<string>
#include<vector>

using namespace std;

class Iterator{
public:
	Iterator(){}
	virtual ~Iterator(){}
	virtual string First()=0;
	virtual string Next()=0;
	virtual string Current()=0;
	virtual bool IsDone()=0;
};

class Aggregate{
public:
	virtual int Count()=0;
	virtual void Push(const string& strValue)=0;
	virtual string Pop(const int nIndex)=0;
	virtual Iterator* CreateIterator()=0;
};

class ConcreteIterator:public Iterator{
public:
	ConcreteIterator(Aggregate* paggregate):m_Aggregate(paggregate),m_nCurrent(0),Iterator(){
		
	}
	string First(){
		return m_Aggregate->Pop(0);
	}
	string Next(){
		string strret;
		m_nCurrent++;
		if(m_nCurrent<m_Aggregate->Count()){
			strret=m_Aggregate->Pop(m_nCurrent);
		}
		return strret;
	}
	string Current(){
		return m_Aggregate->Pop(m_nCurrent);
	}

	bool IsDone(){
		return ((m_nCurrent>=m_Aggregate->Count())?true:false);
	}

private:
	Aggregate* m_Aggregate;
	int m_nCurrent;
};

class ConcreteAggregate:public Aggregate{
public:
	ConcreteAggregate():m_pIterator(NULL){
		m_vecItem.clear();
	}
	~ConcreteAggregate(){
		if(m_pIterator !=NULL){
			delete m_pIterator;
			m_pIterator = NULL;
		}
	}
	Iterator* CreateIterator(){
		if(m_pIterator ==NULL){
			m_pIterator=new ConcreteIterator(this);
		}
		return m_pIterator;
	}
	int Count(){
		return m_vecItem.size();
	}
	void Push(const string& strval){
		m_vecItem.push_back(strval);
	}
	string Pop(const int nIndex){
		string strret="";
		if(nIndex<Count()){
			strret=m_vecItem[nIndex];
		}
		return strret;
	}
private:
	vector<string> m_vecItem;
	Iterator* m_pIterator;
};

int main(){
	ConcreteAggregate *pName=NULL;
	pName=new ConcreteAggregate();
	if(pName!=NULL){
		pName->Push("hello");
		pName->Push("world");
		pName->Push("good");
	}
	Iterator* iter=NULL;
	iter=pName->CreateIterator();
	if(iter!=NULL){
		string stritem=iter->First();
		while(!iter->IsDone()){
			cout<<iter->Current()<<endl;
			iter->Next();
		}
	}
	return 0;
}

4、解释器模式

介绍

解释器模式是指给定一个语言(表达式)，定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子(表达式)。

应用场景：
1、应用可以将一个需要解释执行的语言中的句子表示为一个抽象语法树
2、一些重复出现的问题可以用一种简单的语言来表达
3、一个简单语法需要解释的场景
4、这样的例子还有，比如编译器、运算表达式计算、正则表达式、机器人等。

优点：

可扩展性比较好，灵活。
增加了新的解释表达式的方式。
易于实现简单文法。

缺点：

可利用场景比较少。
对于复杂的文法比较难维护。
解释器模式会引起类膨胀。
解释器模式采用递归调用方法。

角色

  • 一个封装内容的类，拥有一份未解释的内容和一份解释过的内容，以及对它们的获取和设置操作。
  • 一个抽象的表达式的类，声明一个对内容进行解释的功能。
  • 若干个不同的具体的表达式类，每种具体的表达式类都代表一种解释方法，重写相对应的解释操作。

代码实现

模拟加密解密过程。内容类中包含一个原始数字和一个解释后的数字，两种解释操作分别是将原始数字加一和将原始数字减一（假设这分别代表加密和解密）。

#include<iostream>
#include<string>

using namespace std;

class Context{
public:
	Context(int num):m_num(num){
	}

	void setNum(int num){
		m_num=num;
	}
	int getNum(){
		return m_num;
	}	
	void setRes(int res){
		m_res=res;
	}
	int getRes(){
		return m_res;
	}

private:
	int m_num;
	int m_res;
};


class Expression{
public:
	virtual void interpreter(Context* context)=0;
};

class PlusExpression:public Expression{
public:
	virtual void interpreter(Context* context){
		int num=context->getNum();
		num++;
		context->setNum(num);
		context->setRes(num);
	}
};

class MinusExpression:public Expression{
public:
	virtual void interpreter(Context* context){
		int num=context->getNum();
		num--;
		context->setNum(num);
		context->setRes(num);
	}
};

int main(){
	Context* pcxt=new Context(10);
	Expression* e1=new PlusExpression();
	e1->interpreter(pcxt);

	cout<<"plusExpression: "<<pcxt->getRes()<<endl;

	Expression* e2=new MinusExpression();
	e2->interpreter(pcxt);
	cout<<"MinusExpression: "<<pcxt->getRes()<<endl;
	return 0;
}

后记：设计模式的学习到此告一段落，谢谢观看。明天开启新的学习计划。

Sweler*19
关注
C++设计模式16：迭代器模式
琅嬛福地
04-28 1264
迭代器模式是一种行为型设计模式，它允许你在不暴露集合底层表现形式（列表、栈和树等）的情况下遍历集合中所有的元素。迭代器模式通过提供一个迭代器来实现这一点，该迭代器用于跟踪集合中的当前元素，并知道如何遍历到下一个元素。在迭代器模式中，集合类通常会实现一个名为 iterator 的方法，该方法返回一个迭代器对象。迭代器对象通常会实现两个方法：next 和 hasNext。next 方法返回集合中的下一个元素，而 hasNext 方法则用于检查是否还有更多的元素需要遍历。
设计模式——迭代器模式
姑娘眼中的明月色，就只有你一人，轻轻望去，才能发现。
06-08 2427
迭代器模式（Iterator Pattern）定义：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标（Cursor）。迭代器模式是一种对象行为型模式。 英文定义：“Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.”...
JAVA设计模式之行为模式 责任链模式和状态模式
05-28
击鼓传花是一种热闹而又紧张的饮酒游戏。在酒宴上宾客依次坐定位置，由一人击鼓，击鼓的地方与传花的地方是分开的，以示公正。开始击鼓时，花束就开始依次传递，鼓声一落，如果花束在某人手中，则该人就得饮酒，这是很典型的行为责任链模式。 State模式主要解决的是在开发中时常遇到的根据不同的状态需要进行不同的处理操作的问题，而这样的问题，大部分人是采用switch-case语句进行处理的，这样会造成一个问题：分支过多，而且如果加入一个新的状态就需要对原来的代码进行编译。
状态模式&责任链模式&观察者模式&策略模式
weixin_66277385的博客
04-23 426
状态模式(State) 角色 Context：环境角色：用于维护 State 实例,这个实例定义当前状态 State：抽象状态角色：聚合到Context环境角色中 ConcreteState ：具体的状态角色 ConcreteStateA ConcreteStateB ConcreteStateC UML类图 案例：抽奖活动项目设计 public class State { // 当前的状态 private int state; // 供抽奖.
状态模式与责任链模式
qq_38515961的博客
09-23 801
文章目录一、状态模式 一、状态模式 状态模式定义：当一个对象的内在状态改变时允许其改变行为，这个对象看起来像是改变了其类。 状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时，把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的逻辑简化。 State抽象状态类： public abstract class State{ public abstract void handle(Context context); } Context类，维护了一个State类型的对象，这个
责任链模式、状态模式
erose的博客
12-06 696
责任链模式 定义：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条传递链，知道有对象处理它为止。 优缺点 优点： 降低了对象之间的耦合度。该模式使得一个对象无需知道是哪一个对象处理其请求以及链的结构，发送者和接收者也无需拥有对方明确的消息。 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则； 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动他们的次序，也可以动
责任链模式和状态模式对比（转）
weixin_30912051的博客
05-15 252
概述 　　常用23中设计模式中，有三种模式容易混淆，这三种模式即责任链模式、状态模式以及策略模式。现在想深入了解下这3种设计模式的区别，在网上找找之后，发现有一篇博客写的相对清晰。先将内容整理转载如下，也算是对知识的记载和传承； 状态模式与策略模式比较 1、定义： 　　　　状态模式：通过改变对象的内部状态而改变对象自身的行为，这个对象表现得就好像修改了它的类一样。 　　　 策略模式：定...
PHP设计模式之迭代器模式Iterator实例分析【对象行为型】
12-17
迭代器模式（Iterator Pattern）是设计模式中的一种对象行为型模式，主要解决如何在不暴露内部结构的情况下遍历一个聚合对象的问题。在PHP中，迭代器模式允许我们以一致的方式遍历不同类型的集合，比如数组、对象...
设计模式第六讲：责任链模式和迭代器模式详解
a410974689的博客
02-15 484
(1). 定义：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。PS：责任链模式也叫职责链模式。在责任链模式中，客户只需要将请求发送到责任链上即可，无须关心请求的处理细节和请求的传递过程，所以责任链将请求的发送者和请求的处理者解耦了。(2). 优点：A. 降低了对象之间的耦合度。
设计模式 —— 迭代器模式（职责链模式）
Yu_Nan___的博客
06-09 228
迭代器模式（职责链模式） 迭代器模式(Iterator Pattern)：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。 案例：加薪申请、上报与审批 源代码：V1.0 package org.zangyu.Iterator; public class Iterator { public static void main(String[] args) { // TODO Auto-generated method stub
职责链模式VS状态模式
ljianhui的专栏
12-16 7519
今天来进行其他两个模式的对决，1号选手职责链模式，2号选手状态模式。开始对决：职责链模式VS状态模式。 首先来看看1号选手职责链模式的简介，它的定义为：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一对象处理它为止。它的UML图如下： 下面来看看1号选手职责链模式的好处： 当客户
万字解析设计模式之责任链模式、状态模式
最新发布
qq_62377885的博客
11-25 1836
为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。在现实生活中，常常会出现这样的事例：一个请求有多个对象可以处理，但每个对象的处理条件或权限不同。例如，公司员工请假，可批假的领导有部门负责人、副总经理、总经理等，但每个领导能批准的天数不同，员工必须根据自己要请假的天数去找不同的领导签名，也就是说员工必须记住每个领导的姓名、电话和地址等信息，这增加了难度。
状态模式、策略模式、责任链模式(详解)
竹林幽深
10-27 200
原创 一安发表于北京收录于合集#干货分享集174个大家好，我是一安~设计模式分为三种类型，共23种创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式(责任链模式)。
状态模式 VS 职责链模式
忠麦一生
12-05 3981
这次合作开发过程中我们使用了一些设计模式，经过讨论对其理解深刻不少。之前在学习之中，我本以为自己已经理解了一些设计模式。但在这次的使用过程中，因为各自的理解不一造成了一定的碰撞，之后才发现自己的理解根本就站不住脚。于是，反复经过我们的讨论——实施——再讨论，发现理解的偏差，解决之。然后，才有了目前我们认为的比较稳定的，符合逻辑的理解。本篇博客要说的是我对状态模式和职责链模式的理解。这两个设计模式看
【23种设计模式】行为型模式（责任链、命令、解释器模式）
随心所欲的博客
08-17 269
13.责任链【Chain Of Responsibility】 【释义】责任链模式：执行者的不确定性 在责任链模式中，很多对象由每一个对象对其下家的引用而接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。客户并不知道链上的哪一个对象最终处理这个请求，系统可以在不影响客户端的情况下动态的重新组织链和分配责任。处理者有两个选择：承担责任或者把责任推给下家。一个请求可以最终不被任...
Java设计模式之迭代模式（Iterator模式）介绍
09-03
此外，迭代器模式也支持多种遍历策略，如深度优先或广度优先，只要实现相应的迭代器接口即可。 总结来说，迭代模式是设计模式中的一种，主要用于遍历聚合对象的元素。在Java中，通过接口和实现类的方式，我们能够...
设计模式之迭代器和职责链模式
02-21
ChainofResponsibility：(1)、意图：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为支。(2)、适用性：A、有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。B、你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。C、可处理一个请求的对象集合应被动态指定。(3)、优缺点：A、降低耦合度：该模式使得一个对象无需知道是其它哪一个对象处理其请求。对象仅需知道该请求会被”正确”地处理。接收者和发送者都没有对方的明确的信息，且链中的对象不需知道链的结构。结果是，职
责任链模式和状态模式的区别
pzysoft的博客
03-18 2217
责任链模式：当客户提交一个请求时，请求是沿链传递直至有一个ConcreteHander对象负责处理它。接收者和发送者都没有对方的明确信息，且链中的对象自己并不知道链的结构，在运行时自动确定。结果是职责链可简化对象的相互连接，它们仅需保持一个指向其后继者的引用或指针，而不需要保持它所有的候选接受者。这也就大大降低了耦合度了。也就是说，我们可以随时地增加或修改处理一个请求的结构。增强了给对象指派职责的灵
(四)策略模式&状态模式&责任链模式
qq_42193011的博客
08-30 664
策略模式 1、策略模式介绍 实现某一个功能可以有多种算法或者策略，我们根据实际情况选择不同的算法或者策略完成该功能，一般就会用if…else或者switch…case语句来选择具体算法，需要增加一种新的排序算法时，需要修改封装算法类的源代码，违背了ocp原则和单一职责原则，将这些算法抽象出来提供一个统一的接口，不同算法有不同的实现类，让算法独立于使用它的客户而独立 2、策略模式的使用场景 （1）针...
设计模式：行为型——责任链模式、命令模式、备忘录模式、状态模式
肃林的博客
08-02 187
责任链模式、命令模式、备忘录模式、状态模式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值