• 设计模式必知必会系列终章

    目录

    装饰器模式

    工厂方法模式

    抽象工厂模式

    ​编辑

    适配器模式

    代理模式

    装饰器模式

    官方定义:   动态地给⼀个对象增加⼀些额外的职责。就增加功能而言，装饰器模式比生成子类更为灵活。 —— 《设计模式》GoF

    通俗解释:  装饰器是为了给对象增加额外职责而产生的, 有点粉刷的意思, 房子已经存在了, 在房子的表面加上一层粉刷.      (而且它的优势是相较于继承而言的, 相比直接继承, 装饰器更加灵活, 耦合度更低)                     

    应对与  ”过度的采取类继承扩展对象的功能“ 的情况

    继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多（扩展功能的增多），各种子类的组合（扩展功能的组合）会导致子类数量的膨胀。

    (继承下来就是实实在在的一份负担, 代码的膨胀， 类的膨胀.)  但是很多时候其实我们没有必要去继承， 完全可以使用组合的方式来根据需求动态的实现对象功能的扩展, 以解决子类数量膨胀的问题. 使得功能扩展所带来的影响，代价最小，没必要说来一个新的功能扩展就新创建一个类。

    这个类图其实很奇怪, 我刚看见的时候就在想，为啥又是继承, 又是组合的， 继承是为了复用之前的框架, 接口, 裸机 你只有有了之前的房子，才能粉刷装饰吧, 继承体现的是最初的裸机, 接口, 组合完成动态的修饰, 装饰。  

    这个组合还是组合抽象类本身，绝对看的让人很迷，组合的虽然是抽象类本身, 但是抽象类是一个接口，它可以代表它的一切派生类, 这样便使得这个组合对象可扩展性很强.

    模式要点:

    1. 通过采用组合而非继承的手法，Decorator模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的“灵活性差”和“多子类衍生问题”。
    2. Decorator类在接口上表现为is-a Component的继承关系，即Decorator类继承了Component类所具有的接口。但在实现上又表现为has-a Component的组合关系，即Decorator类又使用了另外一个Component类。
    3. Decorator模式的目的并非解决“多子类衍生的多继承”问题，Decorator模式应用的要点在于解决“主体类在多个方向上的扩展功能”——是为“装饰”的含义。

    记忆技巧:  继承复用接口，组合复用实现细节，动态组合

    代码场景: 工资计算, 基本员工的工资是天数*100, 经理员工是基本工资 + 加成add. 老板更是在经理员工的基础上增加10倍加成

    实现代码如下:

    1. #include <iostream>
    2. using namespace std;
    3.  
    4. //此处我没有再写componet类了, 想写的兄弟可以添加喔
    5. class Context {
    6. public:
    7. 	int day;//天数
    8. 	int add;//加成
    9. };
    10.  
    11. //分发奖金: 普通员工仅仅只是day * 100  
    12. //经理  还有加成
    13. //老总等等加成更加牛逼， 在经理的基础上再10倍加成
    14.  
    15. //基础员工工资
    16. //DecoratorClass装饰器基类
    17. class BaseWocker {
    18. public:
    19. 	BaseWocker(BaseWocker* _base) : base(_base) {
    20.  
    21. 	}
    22. 	virtual int CalculateSlary(Context& ctx) {
    23. 		//计算基本工资
    24. 		return ctx.day * 100;
    25. 	}
    26. 	virtual ~BaseWocker() {}
    27. protected:
    28. 	BaseWocker* base;
    29. };
    30.  
    31. //继承复用接口
    32. //BaseWocker继承下来的是裸机, 最初框架， 接口
    33. //组合扩展细节. 运算.
    34. class Manager : BaseWocker {
    35. public:
    36. 	Manager(BaseWocker* _base = nullptr) : BaseWocker(_base) {
    37.  
    38. 	}
    39.  
    40. 	virtual int CalculateSalary(Context& ctx) {
    41. 		int basesalary = base->CalculateSlary(ctx);
    42. 		//...在组合对象的基础上进行扩展运算
    43. 		return basesalary + ctx.add;
    44. 	}
    45. };
    46.  
    47. //Decorator
    48. class Boss : public BaseWocker {
    49. public:
    50. 	Boss(BaseWocker* _base) : BaseWocker(_base) {
    51.  
    52. 	}
    53.  
    54. 	virtual int CalculateSalary(Context& ctx) {
    55. 		int basesalary = base->CalculateSlary(ctx);
    56. 		//...在组合对象的基础上进行扩展运算
    57. 		return (basesalary + (ctx.add * 10));
    58. 	}
    59. };

    如下是大佬写的一份代码: 大家也可以赏析一下:

    1. //业务操作, Component抽象基类
    2. class Stream{
    3.  
    4. public：
    5.     virtual char Read(int number)=0;
    6.     virtual void Seek(int position)=0;
    7.     virtual void Write(char data)=0;
    8.     
    9.     virtual ~Stream(){}
    10. };
    11.  
    12. //主体类具体的Component类
    13. class FileStream: public Stream{
    14. public:
    15.     virtual char Read(int number){
    16.         //读文件流
    17.     }
    18.     virtual void Seek(int position){
    19.         //定位文件流
    20.     }
    21.     virtual void Write(char data){
    22.         //写文件流
    23.     }
    24.  
    25. };
    26.  
    27. class NetworkStream :public Stream{
    28. public:
    29.     virtual char Read(int number){
    30.         //读网络流
    31.     }
    32.     virtual void Seek(int position){
    33.         //定位网络流
    34.     }
    35.     virtual void Write(char data){
    36.         //写网络流
    37.     }
    38.     
    39. };
    40.  
    41. class MemoryStream :public Stream{
    42. public:
    43.     virtual char Read(int number){
    44.         //读内存流
    45.     }
    46.     virtual void Seek(int position){
    47.         //定位内存流
    48.     }
    49.     virtual void Write(char data){
    50.         //写内存流
    51.     }
    52.     
    53. };
    54.  
    55. //扩展操作
    56. //扩展操作采取的是装饰器类, has a 的特征
    57. DecoratorStream: public Stream{
    58. protected:
    59.     Stream* stream;//...
    60.     
    61.     DecoratorStream(Stream * stm):stream(stm){
    62.     
    63.     }
    64.     
    65. };
    66.  
    67. //具体的decorator类
    68. class CryptoStream: public DecoratorStream {
    69.  
    70.  
    71. public:
    72.     CryptoStream(Stream* stm):DecoratorStream(stm){
    73.     
    74.     }
    75.     
    76.     
    77.     virtual char Read(int number){
    78.        
    79.         //额外的加密操作...
    80.         stream->Read(number);//读文件流
    81.     }
    82.     virtual void Seek(int position){
    83.         //额外的加密操作...
    84.         stream::Seek(position);//定位文件流
    85.         //额外的加密操作...
    86.     }
    87.     virtual void Write(byte data){
    88.         //额外的加密操作...
    89.         stream::Write(data);//写文件流
    90.         //额外的加密操作...
    91.     }
    92. };
    93.  
    94.  
    95.  
    96. class BufferedStream : public DecoratorStream{
    97.     
    98.     Stream* stream;//...
    99.     
    100. public:
    101.     BufferedStream(Stream* stm):DecoratorStream(stm){
    102.         
    103.     }
    104.     //...
    105. };

    工厂方法模式

    官方定义: 定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟（目的：解耦，手段：虚函数）到子类。——《设计模式》GoF

    通俗解释：简单来说就是在工厂基类中定义一个抽象接口,  将整个接口的实例化延迟到一个具体的子类工厂(具体工厂)，解耦合.                     ----    之后对于工厂的依赖都是依赖稳定的工厂基类

    这个类图感觉不算特别完善, 最好可以在Factory下面在继承具体的Factory感觉比较好.

    实现代码如下：

    1. //抽象产品类
    2. class Operator {
    3. public:
    4. 	Operator(int l, int r) 
    5. 		: lhs(l)
    6. 		, rhs(r) {
    7. 	}
    8.  
    9. 	//抽象操作
    10. 	virtual int Operation() = 0; 
    11. 	virtual ~Operator() {}
    12. protected:
    13. 	int lhs;
    14. 	int rhs;
    15. };
    16.  
    17. //具体产品类
    18. class AddOperator : public Operator{
    19. public:
    20. 	AddOperator(int l, int r)
    21. 		: Operator(l, r) {
    22.  
    23. 	}
    24. 	virtual int Operation() {
    25. 		return lhs + rhs;
    26. 	}
    27. };
    28.  
    29. class SubOperator : public Operator{
    30.  
    31. public:
    32. 	SubOperator(int l, int r)
    33. 		: Operator(l, r) {
    34.  
    35. 	}
    36. 	virtual int Operation() {
    37. 		return lhs - rhs;
    38. 	}
    39. };
    40.  
    41. class MulOperator : public Operator{
    42.  
    43. public:
    44. 	MulOperator(int l, int r)
    45. 		: Operator(l, r) {
    46.  
    47. 	}
    48. 	virtual int Operation() {
    49. 		return lhs * rhs;
    50. 	}
    51. };
    52.  
    53.  
    54. class DivOperator : public Operator{
    55. public:
    56. 	DivOperator(int l, int r)
    57. 		: Operator(l, r) {
    58.  
    59. 	}
    60. 	virtual int Operation() {
    61. 		if (rhs == 0) {
    62. 			cerr << "zero div" << endl;
    63. 			return 0;
    64. 		}
    65. 		return lhs / rhs;
    66. 	}
    67. };
    68.  
    69.  
    70. //工厂基类
    71. class OperatorFactory {
    72. public:
    73. 	//创建对象的接口, 实例化延迟到子类， 工厂方法FactoryMethod
    74. 	virtual Operator* CreateMethod(int, int) = 0;
    75. };
    76.  
    77. //具体工厂
    78. class AddOperatorFactory : public OperatorFactory {
    79. public:
    80. 	virtual Operator* CreateMethod(int lhs, int rhs) override {
    81. 		return new AddOperator(lhs, rhs);
    82. 	}
    83. };
    84.  
    85. class SubOperatorFactory : public OperatorFactory {
    86. public:
    87. 	virtual Operator* CreateMethod(int lhs, int rhs) {
    88. 		return new SubOperator(lhs, rhs);
    89. 	}
    90. };
    91.  
    92. class MulOperatorFactory : public OperatorFactory {
    93. public:
    94. 	virtual Operator* CreateMethod(int lhs, int rhs) {
    95. 		return new MulOperator(lhs, rhs);
    96. 	}
    97. };
    98.  
    99. class DivOperatorFactory : public OperatorFactory {
    100. public:
    101. 	virtual Operator* CreateMethod(int lhs, int rhs) {
    102. 		return new DivOperator(lhs, rhs);
    103. 	}
    104. };
    105.  
    106.  
    107. int main() {
    108.  
    109. 	int l;
    110. 	int r;
    111. 	char op;
    112.  
    113. 	while (1) {
    114. 		cout << "请输入lhs, rhs: " << endl;
    115. 		cin >> l >> r;
    116. 		cout << "请输入操作方法op: " << endl;
    117. 		cin >> op;
    118. 		OperatorFactory* factory = nullptr;
    119. 		//创建工厂
    120. 		switch (op) {
    121. 			case '+': {
    122. 				factory = new AddOperatorFactory();
    123. 			} break;
    124. 			case '-': {
    125. 				factory = new SubOperatorFactory();
    126. 			} break;
    127. 			case '*': {
    128. 				factory = new MulOperatorFactory();
    129. 			} break;
    130. 			case '/': {
    131. 				factory = new DivOperatorFactory();
    132. 			} break;
    133. 		}
    134. 		//生产产品运行Operaction
    135. 		cout << factory->CreateMethod(l, r)->Operation() << endl;
    136. 	}
    137. 	getchar();
    138. 	return 0;
    139. }

     要点:

    1. Factory Method模式用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系(new)会导致软件的脆弱。
    2. Factory Method模式通过面向对象的手法，将所要创建的具体对象工作延迟到子类，从而实现一种扩展（而非更改）的策略，较好地解决了这种紧耦合关系。
    3. Factory Method模式解决“单个对象”的需求变化。缺点在于要求创建方法/参数相同。

    使用场景:

    解决创建过程比较复杂，希望对外隐藏这些细节；

    1. 比如连接池，线程池；
    2. 隐藏对象真实类型；
    3. 对象创建会有很多参数来决定如何创建；
    4. 创建对象有复杂的依赖关系；

    本质记忆技巧:  延迟到子类进行创建实现

    抽象工厂模式

    提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。——《设计模式》GoF

    通俗解释：本质上来讲, 无论是抽象工厂模式, 还是简工厂方法模式，均是属于对象创建模式. 抽象工厂模式相对于工厂方法而言核心差别在于它是负责相关联的一系列的产品, 对象的创建. 不再是单个产品的创建, 而是系列产品的创建, 两者差别仅此而已.

    一个抽象工厂下面的两个具体工厂生产的两种产品是搭配产品。好比如说：瓶身与瓶盖两个产品的加工厂. 产品相互依赖，配套.  可以进行扩展, 比如说瓶子也有种类，矿泉水瓶，可口可乐瓶子，芬达瓶子等等. 这个瓶身瓶盖一定是配套生产的.       (对应一系列相关，相互依赖的对象)

    1. //产品抽象类A
    2. class IProductA {
    3. public:
    4. 	//对于产品的操作
    5. 	virtual void Operation() = 0;
    6. 	virtual ~IProductA() {}
    7. };
    8.  
    9. //产品抽象类B
    10. class IProductB {
    11. public:
    12. 	//对于产品的操作
    13. 	virtual void Operation() = 0;
    14. 	virtual ~IProductB() {}
    15. };
    16.  
    17. //抽象工厂 A 瓶身, B 瓶盖
    18. class IFactory {
    19. public:
    20. 	virtual IProductA* FactoryMethodA() = 0;//创建产品A
    21. 	virtual IProductB* FactoryMethodB() = 0;//创建产品B
    22. 	virtual ~IFactory() {}
    23. };
    24.  
    25.  
    26. //具体的产品
    27. class PingSheng : public IProductA {
    28. public:
    29. 	virtual void Operation() {
    30. 		cout << "我是瓶身" << endl;
    31. 	}
    32. };
    33.  
    34. class PingGai : public IProductB {
    35. public:
    36. 	virtual void Operation() {
    37. 		cout << "我是瓶盖" << endl;
    38. 	}
    39. 	
    40. };
    41.  
    42. //具体的工厂
    43. class PingZiFactory : public IFactory {
    44. 	virtual IProductA* FactoryMethodA() {
    45. 		return new PingSheng();
    46. 	}
    47. 	virtual IProductB* FactoryMethodB() {
    48. 		return new PingGai();
    49. 	}
    50. };

    记忆技巧:  配套产品生产

    适配器模式

    定义: 将一个类的接口转换为用户需要的另一个接口。Adapter使得原本由于接口不兼容不能在一起工作的那些类可以一起工作。 ——《设计模式》GoF

    通俗解释：简单来说就是适配接口, 本来一个类的接口是和用户需要的接口不统一的, 但是现在需要使用这个类的一些功能， 于是可以抽象出来一个中间的适配器类, 进行组合这个需要使用的类对象，并且适配接口，进而实现接口不兼容的类功能, 接口也可以使用.

    说到适配器模式，我还想说所有学习C++的大家，只要学了STL, 容器适配器学的还不错的，仿写过stack,queue两个容器适配器的实现的，你们都已经使用了适配器模式了. 只是当时还不知道自己用的是适配器模式. 想想好像确实就是适配新的接口.       

    push_back-----> push   pop_back ----> pop   针对stack而言

    场景引入, 简单实现一下适配器模式

    1. //目标接口, 新接口.
    2. class ITarget {
    3. public:
    4. 	virtual void Request() = 0;
    5. };
    6.  
    7. //需要复用的老旧接口
    8. class Adaptee {
    9. public:
    10. 	virtual void RequestOne() = 0;
    11. 	virtual void RequestTwo() = 0;
    12. };
    13.  
    14. //具体的旧类型, 老旧的库， 需要适配复用其中的Request
    15. class Old : public Adaptee {
    16. public:
    17. 	virtual void RequestOne() {
    18. 		cout << "处理需求1" << endl;
    19. 	}
    20.  
    21. 	virtual void RequestTwo() {
    22. 		cout << "处理需求2" << endl;
    23. 	}
    24. };
    25.  
    26. //接口的不一致，需要产生一个Adapter接口适配器类, 适配接口
    27. //适配ITarget目标类接口
    28.  
    29. //继承目标类适配接口
    30. class Adapter : public ITarget {
    31. protected:
    32. 	Adaptee* adaptee;//组合复用老旧接口
    33. public:
    34. 	virtual void Request() {
    35. 		adaptee->RequestOne();
    36. 		adaptee->RequestTwo();
    37. 	}
    38. };
    39.  
    40. class Client {
    41. private:
    42. 	ITarget* target;
    43. public:
    44. 	void Click() {// 客户点击, 目标执行需求
    45. 		target->Request();
    46. 	}
    47. };

     要点总结:

    1. Adapter模式主要应用于 "希望复用一些现成类， 但是接口又与复用环境不一致的情况", 在遗留代码复用, 类库迁移方面非常有用
    2. 适配的方式使用的是对象组合的方式， 更加符合松耦合的设计原则
    3. 原来的接口是稳定的，新的外来的需求是变化的，那么可以通过继承原来的接口，让原来的接口继续保持稳定，在子类通过组合的方式来扩展功能。     继承原来的接口(用户需要使用的接口， 复用其他类对象的接口，子类中组合扩展)

    记忆技巧:  继承使得接口转换匹配, 组合复用已有类功能

    代理模式

    官方定义：为其他对象提供⼀种代理以控制（隔离, 使用接口）对这对象的访问。

    ——《设计模式》GoF

    通俗解释：代理完成职责，代理一个具体类完成职责(接口职责, 相同的接口), 常见的代理, 婚庆代理， 代理商.

    代理层出现的原因，背景，优势.

    在有些系统中，为了某些对象的纯粹性，只进行了功能相关封装（稳定点），后期添加了其他功能 需要对该对象进行额外操作（变化点），为了隔离变化点（也就是不直接在稳定点进行修改，这样 会让稳定点也变得不稳定），可以抽象一层代理层

    首先解释一下纯粹性：纯粹性指的是接口中仅仅只是实现功能，而不需要进行权限判断，引用计数等等其他的额外操作

    代理类是一个中介层, 并不做具体的业务细节实现。而是介于客户类和具体的委托代理类之间的中间层. 作用在于对委托代理类使用前后的一些处理扩展, 让真正的RealSubject类保持纯粹  真正的业务功能其实还是委托代理类实现的。代理类是做中间处理和扩展的.        (对已有对象的额外操作, 放在代理层)

    简单实现:

    1. class ISubject {
    2. public:
    3. 	virtual void Handle() = 0;
    4. 	virtual ~ISubject() {}
    5. };
    6.  
    7.  
    8. //真实的Subject对象
    9. //是一个很纯粹的类. 很稳定.
    10. class RealSubject : public ISubject {
    11. public:
    12. 	virtual void Handle() {
    13. 		//纯粹的功能实现
    14. 	}
    15. };
    16.  
    17. //代理类. 扩展变化
    18. class Proxy1 : public  ISubject {
    19. public:
    20. 	Proxy1(ISubject* subject) : _subject(subject) {
    21. 	}
    22.  
    23. 	//实现功能扩展.
    24.  
    25. 	virtual void Handle() {
    26. 		//在访问RealSubject之前的一些操作
    27.  
    28. 		//if (是否不可以访问) return;
    29. 		_subject->Handle();
    30.  
    31. 		//访问玩之后的一些操作
    32. 		++count;//++访问计数等等
    33. 	}
    34. private:
    35. 	ISubject* _subject;
    36. 	static int count;
    37. };
    38.  
    39. int Proxy1::count = 0;
    40.  
    41.  
    42. //代理模式2扩展处理
    43. //在分布式系统中出现的，skynet actor等
    44.  
    45. // 在分布式系统当中  skynet actor
    46. class Proxy2 : public ISubject {
    47. public:
    48. 	virtual void Handle() {
    49. 		// 在访问 RealSubject 之前做一些处理
    50.  
    51. 		// 发送到数据到远端  网络处理  同步非阻塞 ntyco c协程
    52. 		//IResult * val = rpc->call("RealSubject", "Handle");
    53.  
    54. 		// 在访问 RealSubject 之后做一些处理
    55. 	}
    56. private:
    57. 	/*void callback(IResult * val) {
    58. 	// 在访问 RealSubject 之后做一些处理
    59. 	}*/
    60. };

    模式要点：

    1. 远程代理（隐藏⼀个对象存在不同的地址空间的事实），虚代理（延迟加载lazyload），保护代理（在代理前后做额外操作，权限管理，引用计数等）
    2. 在分布式系统中，actor模型（skynet）等常用的设计模式

    本质：控制对象访问, 代理RealSubject， 处理对RealSubject访问前后的扩展需求. 权限验证, 引用计数等

    1. 好了各位老铁们，设计模式到此结束了.感谢各位兄弟们从一到现在的陪伴
    2. 设计模式的学习确实是有点虚无的.  特别是我们这些没啥工作经验的，学完之后根本不知道咋用到实际项目中实现重构项目的设计，持续重构形成自己的设计模式。 我们也没有经历过没有任何设计原则的Bad Smell Code的维护，所以体会是没有实践过的前辈们深入的
    3. 但是我觉得提早了解和具备遵循设计原则这样的大思想是我们需要具备的，不一定强行套入设计模式，可以先是我们的代码遵循设计原则。    遵循设计原则的代码往往更容易重构和维护
    4. IT技术路漫长久远。。                 ----  感谢各位大佬的支持，让我们继续加油，工作的前辈升职加薪，学习的友友学业有成，争取保研
  • 相关阅读:
    LazSerial - 二进制数据传输方式
    java计算机毕业设计小区宠物管理系统源码+系统+数据库+lw文档
    C语言 0 —— 信息在计算机中的表示
    低温下安装振弦采集仪注意事项
    [PHP]str_split性能问题
    网页保存为pdf神器（可自定义编辑）—Print Edit WE
    【Java集合类】之Map集合的特点及使用
    超声检测技术(一)
    Django自定义manage.py命令实现hexo博客迁移
    CentOS8上部署NFS服务端和客户端
  • 原文地址：https://blog.csdn.net/weixin_53695360/article/details/125259745