装饰，即为扩展。为一个主体扩展一些其他操作。而装饰中间类即为扩展提供了一个规范，如此变可以通过组合的方式，完整复杂的多功能扩展。

代码：流操作

第一个版本

流操作的需求

  1. 流的类型：文件流、网络流、内存流
  2. 流的操作：加密、缓存

对于这些流操作的需求，我们很容易想到要有一个基类。

  1. //业务操作
  2. class Stream {
  3. public:
  4.     virtual char Read(int number) = 0;
  5.     virtual void Seek(int position) = 0;
  6.     virtual void Write(char data) = 0;
  8.     virtual ~Stream(){}
  9. }
  11. //主体类
  12. class FileStream : public Stream { //文件流
  13. public:
  14.     virtual char Read(int number) {
  15.         //读文件流
  16.     }
  17.     virtual void Seek(int position) {
  18.         //定位文件流
  19.     }
  20.     virtual void Write(char data) {
  21.         //写文件流
  22.     }
  23. }
  25. class NetworkStream : public Stream {
  26. public:
  27.     virtual char Read(int number) {
  28.         //读网络流
  29.     }
  30.     virtual void Seek(int position) {
  31.         //定位网络流
  32.     }
  33.     virtual void Write(char data) {
  34.         //写网络流
  35.     }
  36. }
  38. class MemoryStream : public Stream{
  39. public:
  40.     virtual char Read(int number) {
  41.         //读内存流
  42.     }
  43.     virtual void Seek(int position) {
  44.         //定位内存流
  45.     }
  46.     virtual void Write(char data) {
  47.         //写内存流
  48.     }
  49. }
  51. //第一种扩展操作：加密
  52. class CryptoFileStream :public FileStream{ //对文件流加密
  53. public:
  54.     virtual char Read(int number){
  55.         //额外的加密操作...
  56.         FileStream::Read(number);    //读文件流
  57.     }
  58.     virtual void Seek(int position){
  59.         //额外的加密操作...
  60.         FileStream::Seek(position);    //定位文件流
  61.         //额外的加密操作...
  62.     }
  63.     virtual void Write(byte data){
  64.         //额外的加密操作...
  65.         FileStream::Write(data);    //写文件流
  66.         //额外的加密操作...
  67.     }
  68. };
  70. class CryptoNetworkStream :public NetworkStream{ //对网络流加密
  71. public:
  72.     virtual char Read(int number){
  73.         //额外的加密操作...
  74.         NetworkStream::Read(number);//读网络流
  75.     }
  76.     virtual void Seek(int position){
  77.         //额外的加密操作...
  78.         NetworkStream::Seek(position);//定位网络流
  79.         //额外的加密操作...
  80.     }
  81.     virtual void Write(byte data){
  82.         //额外的加密操作...
  83.         NetworkStream::Write(data);//写网络流
  84.         //额外的加密操作...
  85.     }
  86. };
  88. class CryptoMemoryStream : public MemoryStream{ //内存流的加密操作
  89. public:
  90.     virtual char Read(int number){
  91.         //额外的加密操作...
  92.         MemoryStream::Read(number);//读内存流
  93.     }
  94.     virtual void Seek(int position){
  95.         //额外的加密操作...
  96.         MemoryStream::Seek(position);//定位内存流
  97.         //额外的加密操作...
  98.     }
  99.     virtual void Write(byte data){
  100.         //额外的加密操作...
  101.         MemoryStream::Write(data);//写内存流
  102.         //额外的加密操作...
  103.     }
  104. };
  106. //第二种扩展操作：缓存操作
  107. class BufferedFileStream : public FileStream{
  108.     //...
  109. };
  111. class BufferedNetworkStream : public NetworkStream{
  112.     //...
  113. };
  115. class BufferedMemoryStream : public MemoryStream{
  116.     //...
  117. }
  119. //第三种扩展操作：既加密，又缓存
  120. class CryptoBufferedFileStream :public FileStream{
  121. public:
  122.     virtual char Read(int number){
  123.         //额外的加密操作...
  124.         //额外的缓冲操作...
  125.         FileStream::Read(number);//读文件流
  126.     }
  127.     virtual void Seek(int position){
  128.         //额外的加密操作...
  129.         //额外的缓冲操作...
  130.         FileStream::Seek(position);//定位文件流
  131.         //额外的加密操作...
  132.         //额外的缓冲操作...
  133.     }
  134.     virtual void Write(byte data){
  135.         //额外的加密操作...
  136.         //额外的缓冲操作...
  137.         FileStream::Write(data);//写文件流
  138.         //额外的加密操作...
  139.         //额外的缓冲操作...
  140.     }
  141. };
  143. void Process(){
  144.     //编译时装配
  145.     CryptoFileStream *fs1 = new CryptoFileStream();
  147.     BufferedFileStream *fs2 = new BufferedFileStream();
  149.     CryptoBufferedFileStream *fs3 =new CryptoBufferedFileStream();
  150. }

继承关系：
image.png

问题一：类的规模

  1. Stream这一层是1，假设第二层的变化是n个，第三层的变化是m
  2. 不是m*n，他们可能有组合的情况，既加密又缓存
  3. 第三层结点个数：n*(m+ m-1 + m-2 + m-3 ... + 1)

问题二：代码冗余

  1. 加密操作其实都是一样的（CryptoMemoryStream::Read、CryptoNetworkStream::Read、CryptoFileStream::Read三者的加密操作其实是一样的）
  2. 缓存的操作其实都是一样的

优化：去除代码冗余

根据组合优于继承原则，我们将继承改为组合

  1. //...
  3. //第一种扩展操作：加密
  4. class CryptoFileStream /*:public FileStream*/
  5.                         //删除继承关系
  6. {
  7.     FileStream* stream;    //改为组合关系
  9. public:
  10.     virtual char Read(int number){
  11.         //额外的加密操作...
  13.         //FileStream::Read(number);    //调用父类读文件流的方法
  14.         //改为直接用字段的函数
  15.         stream->Read(number);
  16.     }
  17.     //...
  18. };
  20. class CryptoNetworkStream /*:public NetworkStream*/
  21. {
  22.     NetworkStream* stream;
  24. public:
  25.     virtual char Read(int number){
  26.         //额外的加密操作...
  27.         //NetworkStream::Read(number);//读网络流
  28.         stream->Read(number);
  29.     }
  30.        //...
  31. };
  33. class CryptoMemoryStream /*: public MemoryStream*/
  34. {
  35.     MemoryStream* stream;
  37. public:
  38.     virtual char Read(int number){
  39.         //额外的加密操作...
  40.         //MemoryStream::Read(number);//读内存流
  41.         stream->Read(number);
  42.     }
  43.        //...
  44. };

优化：使用父类多态

当一个变量的声明类型有共同的父类时，我们可以直接声明为它们的父类——马丁·福勒经典重构理论

在上个版本中，CryptoFileStream::stream、CryptoNetworkStream::stream、CryptoMemoryStream::stream三个变量的声明类型有共同的父类，即Stream。
我们可以直接把它们写成Stream类型的指针，通过多态来调用函数
在未来，使用的时候，再传具体的类型（在运行时指定具体类型，编译时不指定）

  1. //...
  3. //第一种扩展操作：加密
  4. class CryptoFileStream
  5. {
  6.     Stream* stream;    //在未来，赋值为FileStream。即= new FileStream();
  8. public:
  9.     virtual char Read(int number){
  10.         //额外的加密操作...
  11.         stream->Read(number);
  12.     }
  13.     //...
  14. };
  16. class CryptoNetworkStream
  17. {
  18.     Stream* stream; // = new NetworkStream();
  20. public:
  21.     virtual char Read(int number){
  22.         //额外的加密操作...
  23.         stream->Read(number);
  24.     }
  25.        //...
  26. };
  28. class CryptoMemoryStream
  29. {
  30.     Stream* stream; // = new MemoryStream();
  32. public:
  33.     virtual char Read(int number){
  34.         //额外的加密操作...
  35.         stream->Read(number);
  36.     }
  37.        //...
  38. };

优化：抽出父类（第二个大版本）

经过上两个版本的迭代，发现CryptoFileStream、CryptoNetworkStream、CryptoMemoryStream变成一样了。只不过字段stream的具体类型需要在运行时指定。

  1. class CryptoStream 
  2.     : public Stream //继承Stream基类，为了让Read、Seek、Write函数满足接口规范（和stream的函数一样），成为一个虚函数
  3. {
  4.     Stream* stream;    //运行时再指定，编译时声明为基类指针
  6. public:
  7.     CryptoStream(Stream* stm):stream(stm){
  8.     }
  10.     virtual char Read(int number){
  11.         //额外的加密操作...
  12.         stream->Read(number);//读文件流（多态调用）
  13.     }
  14.     virtual void Seek(int position){
  15.         //额外的加密操作...
  16.         stream::Seek(position);//定位文件流（多态调用）
  17.         //额外的加密操作...
  18.     }
  19.     virtual void Write(byte data){
  20.         //额外的加密操作...
  21.         stream::Write(data);//写文件流（多态调用）
  22.         //额外的加密操作...
  23.     }
  24. };

至此，问题已经得到了极大的缓解了。以下是此次迭代的完整代码

  1. //业务操作
  2. class Stream{
  3. public：
  4.     virtual char Read(int number)=0;
  5.     virtual void Seek(int position)=0;
  6.     virtual void Write(char data)=0;
  8.     virtual ~Stream(){}
  9. };
  11. //主体类
  12. class FileStream: public Stream{
  13. public:
  14.     virtual char Read(int number){
  15.         //读文件流
  16.     }
  17.     virtual void Seek(int position){
  18.         //定位文件流
  19.     }
  20.     virtual void Write(char data){
  21.         //写文件流
  22.     }
  23. };
  25. class NetworkStream :public Stream{
  26. public:
  27.     virtual char Read(int number){
  28.         //读网络流
  29.     }
  30.     virtual void Seek(int position){
  31.         //定位网络流
  32.     }
  33.     virtual void Write(char data){
  34.         //写网络流
  35.     }
  36. };
  38. class MemoryStream :public Stream{
  39. public:
  40.     virtual char Read(int number){
  41.         //读内存流
  42.     }
  43.     virtual void Seek(int position){
  44.         //定位内存流
  45.     }
  46.     virtual void Write(char data){
  47.         //写内存流
  48.     }
  49. };
  51. //第一种扩展操作：加密
  52. class CryptoStream: public Stream {
  53.     Stream* stream;//...
  55. public:
  56.     CryptoStream(Stream* stm):stream(stm){
  57.     }
  59.     virtual char Read(int number){
  60.         //额外的加密操作...
  61.         stream->Read(number);//读文件流
  62.     }
  63.     virtual void Seek(int position){
  64.         //额外的加密操作...
  65.         stream::Seek(position);//定位文件流
  66.         //额外的加密操作...
  67.     }
  68.     virtual void Write(byte data){
  69.         //额外的加密操作...
  70.         stream::Write(data);//写文件流
  71.         //额外的加密操作...
  72.     }
  73. };
  75. //第二种扩展操作：缓存
  76. class BufferedStream : public Stream{
  77.     Stream* stream;//...
  79. public:
  80.     BufferedStream(Stream* stm):stream(stm){
  81.     }
  82.     //...
  83. };
  85. //运行时装配
  86. //1. 编译不存在加密文件流、缓存文件流、加密缓存文件流。我们没有那样的类
  87. //2. 但是在运行的时候，我们可以通过组合的方式把它们装配起来，满足我们的需求
  88. void Process(){
  89.     //创建一个文件流
  90.     FileStream* s1 = new FileStream();
  92.     //传入s1文件流，s2为文件流的加密操作
  93.     CryptoStream* s2 = new CryptoStream(s1);
  95.     //传入s1文件流，s3为文件流的缓存操作
  96.     BufferedStream* s3 = new BufferedStream(s1);
  98.     //传入s2文件流加密操作，s4为文件流加密操作 + 缓存操作
  99.     BufferedStream* s4 = new BufferedStream(s2);
  100. }

优化：再抽象出父类，即装饰器（第三个大版本）

其实不难看出，CryptoStream、BufferedStream还存在冗余代码。有着一个相同的成员变量。

如果某一个类的多个子类有着共同的字段，我们可以把这个字段往上提一层——马丁·福勒经典重构理论

Stream的子类CryptoStream、BufferedStream有着共同的字段Stream* stream，所以我们可以把它们往上再提一层

我们有两种提法。
一、第一种提法：把Stream* stream提到基类中（即Stream里）

  1. class Stream{
  2.     Stream* stream;
  4. public：
  5.     virtual char Read(int number)=0;
  6.     virtual void Seek(int position)=0;
  7.     virtual void Write(char data)=0;
  9.     virtual ~Stream(){}
  10. };

提到父类Stream中，但这会有一个问题。主体类FileStream、NetworkStream、MemoryStream都不需要这个字段

二、第二种提法：设计一个中间类

  1. //中间的装饰类
  2. class DecoratorStream: public Stream{
  3. protected: //子类要用，申明为protected
  4.     Stream* stream;//...
  6.     DecoratorStream(Stream * stm):stream(stm){
  7.     }
  8. };

第二种提法是可以的，其实就是我们的装饰设计模式

完整代码：

  1. //业务操作
  2. class Stream{
  3. public：
  4.     virtual char Read(int number)=0;
  5.     virtual void Seek(int position)=0;
  6.     virtual void Write(char data)=0;
  8.     virtual ~Stream(){}
  9. };
  11. //主体类
  12. class FileStream: public Stream{
  13. public:
  14.     virtual char Read(int number){
  15.         //读文件流
  16.     }
  17.     virtual void Seek(int position){
  18.         //定位文件流
  19.     }
  20.     virtual void Write(char data){
  21.         //写文件流
  22.     }
  23. };
  25. class NetworkStream :public Stream{
  26. public:
  27.     virtual char Read(int number){
  28.         //读网络流
  29.     }
  30.     virtual void Seek(int position){
  31.         //定位网络流
  32.     }
  33.     virtual void Write(char data){
  34.         //写网络流
  35.     }
  36. };
  38. class MemoryStream :public Stream{
  39. public:
  40.     virtual char Read(int number){
  41.         //读内存流
  42.     }
  43.     virtual void Seek(int position){
  44.         //定位内存流
  45.     }
  46.     virtual void Write(char data){
  47.         //写内存流
  48.     }
  49. };
  51. //提供一个中间装饰类，为Stream的扩展操作提供一个基类
  52. DecoratorStream: public Stream{
  53. protected:
  54.     Stream* stream;//...
  56.     DecoratorStream(Stream * stm):stream(stm){
  57.     }
  58. };
  60. //扩展操作一：加密操作
  61. class CryptoStream: public DecoratorStream {
  62. public:
  63.     CryptoStream(Stream* stm):DecoratorStream(stm){    
  64.     }
  66.     virtual char Read(int number){   
  67.         //额外的加密操作...
  68.         stream->Read(number);//读文件流
  69.     }
  70.     virtual void Seek(int position){
  71.         //额外的加密操作...
  72.         stream::Seek(position);//定位文件流
  73.         //额外的加密操作...
  74.     }
  75.     virtual void Write(byte data){
  76.         //额外的加密操作...
  77.         stream::Write(data);//写文件流
  78.         //额外的加密操作...
  79.     }
  80. };
  82. //扩展操作二：缓存操作
  83. class BufferedStream : public DecoratorStream{
  84.     //与CryptoStream类似
  85. };
  87. void Process(){
  88.     //运行时装配
  89.     FileStream* s1=new FileStream(); //只需要一个文件流，没有加密、缓存的操作
  91.     //加密流必须传入一个流进来，这就是扩展操作，你在谁的基础上再做操作
  92.     //这就是装饰的含义，附着在其他之上的操作
  93.     CryptoStream* s2=new CryptoStream(s1);    //文件加密流
  95.     BufferedStream* s3=new BufferedStream(s1); //文件缓存流
  97.     BufferedStream* s4=new BufferedStream(s2);
  98. }

说明：装饰的含义，就是附着在本体之上的其他操作，即扩展操作。所以如果你要使用装饰的话，必须指定其本体是谁
例如：

  1. FileStream* s1=new FileStream(); 
  2. //只需要一个文件流，没有加密、缓存的操作
  4. //加密流（加密流是装饰类的子类），它必须传入一个流进来
  5. //这就是扩展操作，你在谁的基础上再做操作
  6. //这就是装饰的含义，附着在本体之上的操作
  7. CryptoStream* s2=new CryptoStream(s1);    //文件加密流
第一个版本 第三个版本（装饰模式）
类图 image.png image.png
类规模 1+n+n*m!/2 **1+n+1+m**

为什么两个版本类规模差异如此之大？

  • 第一个版本背后有很多重复代码
  • 是对继承的不良使用，使用组合更好。用组合的方式支持未来的一种变化

**
举例：每个英雄都可以放QWER技能

动机

在某些情况下我们可能会“过渡地使用继承来扩展对象的功能”，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多（扩展功能的增多），各种子类的组合（扩展功能的组合）会导致更多子类的膨胀。

  1. 静态特质：第一个版本CryptoFileStream类中FileStream::Read(number);，这永远是调用FileStream的Read函数，是不会变化的代码。这个是由继承实现的
  2. 动态特质：在第三个版本中，CryptoStream类中的stream->Read(number)。这句代码是用多态指针来调虚函数，这句话就有变化了。这个是由组合实现的

如何使“对象功能的扩展”能够根据需要来动态地实现？
同时避免“扩展功能的增多”带来子类膨胀问题？
从而使得任何“功能扩展变化”所导致的影响降为最低？

模式定义

动态（组合）地给一个对象增加一些额外的职责。就增加功能而言，Decorator模式比生成子类（继承）更为灵活（消除重复代码&减少子类个数）。——《设计模式》GOF

结构

image.png

要点总结

要点一： 通过采用组合而非继承的手法，Decorator模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的“灵活性差”和“多子类衍生问题”

要点二：Decorator类在接口上表现为is-a Component的继承关系，即Decorator类继承了Component类所具有的接口。但在实现上又表现为has-a Component的组合关系，即Decorator类又使用了另外一个Component类

  1. Decorator类既继承Stream，又组合Stream（内部有一个Stream类型的多态指针）
  2. 如果一个类B继承与A类，又具有一个A类的指针 => 99%是Decorator设计模式 => 正常情况不会这么干，要不就只有继承，要不就只有组合，不会两个都有；两个都有的情况一般都是装饰模式
  3. 组合Steam是为了什么？将来支持调用Stream的具体实现类（如FileStream、NetworkStream、MemoryStream）
  4. 继承Stream是为了什么？把它自己也声明为一个流，为了让Read、Seek、Write函数满足接口规范（和stream的函数一样），成为一个虚函数
  5. 有时候你可能看不到人家的内部字段（看不到人家有组合）。但类B继承于A，B的构造函数里还需要传A的指针，你也能判断B内部有A，B和A也有组合关系

要点三：Decorator模式的目的并非解决“多子类衍生的多继承”问题，Decorator模式应用的要点在于解决“主体类在多个方向上的扩展功能”——是为了“装饰”的含义
image.png

  1. FileStream和Stream是继承关系，但是CryptoFileStream和FileStream是继承关系嘛？非要继承吗？
    1. 不是的，它俩（Stream->FileStream；FileStream->CryptoFileStream）都不是一个变化的方向
    2. 实际上FileStream->CryptoFileStream是扩展操作，是扩展的方向；而Stream->FileStream是主体操作
    3. 主体操作和扩展操作应该分开成两个分支进行继承

image.png