标签：查看 基础上 new char 代码 面向对象 技术分享 参考文献 本质
4. “单一职责”类模式
在软件组件的设计中，如果责任划分的不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。
典型模式代表： Decorator，Bridge
4.1 Decorator 装饰模式
代码示例：不同的流操作（文件流，网络流，内存流）及其扩展功能（加密，缓冲）等的实现
实现代码1：
类图结构示意（大量使用继承）
数据规模： 假设有n种文件，m种功能操作。该实现方法有（1 + n + n * m! / 2） 数量级的子类；
同时考察59行，79行，98行本身是相同的代码（类似还有很多），存在大量的冗余和重复。
开始重构，见方法2.
1 //Decorator1.cpp
2 //业务操作
3 class Stream{
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 //主体类
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 class CryptoFileStream :public FileStream{
57 public:
58 virtual char Read(int number){
59
60 //额外的加密操作...
61 FileStream::Read(number);//读文件流
62
63 }
64 virtual void Seek(int position){
65 //额外的加密操作...
66 FileStream::Seek(position);//定位文件流
67 //额外的加密操作...
68 }
69 virtual void Write(byte data){
70 //额外的加密操作...
71 FileStream::Write(data);//写文件流
72 //额外的加密操作...
73 }
74 };
75
76 class CryptoNetworkStream : :public NetworkStream{
77 public:
78 virtual char Read(int number){
79
80 //额外的加密操作...
81 NetworkStream::Read(number);//读网络流
82 }
83 virtual void Seek(int position){
84 //额外的加密操作...
85 NetworkStream::Seek(position);//定位网络流
86 //额外的加密操作...
87 }
88 virtual void Write(byte data){
89 //额外的加密操作...
90 NetworkStream::Write(data);//写网络流
91 //额外的加密操作...
92 }
93 };
94
95 class CryptoMemoryStream : public MemoryStream{
96 public:
97 virtual char Read(int number){
98
99 //额外的加密操作...
100 MemoryStream::Read(number);//读内存流
101 }
102 virtual void Seek(int position){
103 //额外的加密操作...
104 MemoryStream::Seek(position);//定位内存流
105 //额外的加密操作...
106 }
107 virtual void Write(byte data){
108 //额外的加密操作...
109 MemoryStream::Write(data);//写内存流
110 //额外的加密操作...
111 }
112 };
113
114 class BufferedFileStream : public FileStream{
115 //...
116 };
117
118 class BufferedNetworkStream : public NetworkStream{
119 //...
120 };
121
122 class BufferedMemoryStream : public MemoryStream{
123 //...
124 }
125
126
127
128
129 class CryptoBufferedFileStream :public FileStream{
130 public:
131 virtual char Read(int number){
132
133 //额外的加密操作...
134 //额外的缓冲操作...
135 FileStream::Read(number);//读文件流
136 }
137 virtual void Seek(int position){
138 //额外的加密操作...
139 //额外的缓冲操作...
140 FileStream::Seek(position);//定位文件流
141 //额外的加密操作...
142 //额外的缓冲操作...
143 }
144 virtual void Write(byte data){
145 //额外的加密操作...
146 //额外的缓冲操作...
147 FileStream::Write(data);//写文件流
148 //额外的加密操作...
149 //额外的缓冲操作...
150 }
151 };
152
153
154
155 void Process(){
156
157 //编译时装配
158 CryptoFileStream *fs1 = new CryptoFileStream();
159
160 BufferedFileStream *fs2 = new BufferedFileStream();
161
162 CryptoBufferedFileStream *fs3 =new CryptoBufferedFileStream();
163
164 }
实现代码2：
针对上述代码，重构步骤如下：
1）考察 CryptoFileStream ，CryptoNetworkStream，CryptoMemoryStream三个类，将其继承FileStream，NetworkStream，NetworkStream改为组合；即
1 class CryptoFileStream{
2 FileStream* stream;
3 public:
4 virtual char Read(int number){
5
6 //额外的加密操作...
7 stream -> Read(number);//改用字段方式调用Read()
8 // ...seek() write() 同理
9 }
10 }
11
12 class CryptoNetworkStream{
13 NetworkStream* stream;
14 public:
15 virtual char Read(int number){
16
17 //额外的加密操作...
18 stream -> Read(number);//改用字段方式调用Read()
19 //... seek() write() 同理
20 }
21 }
22
23 class CryptoMemoryStream{
24 MemoryStream* stream;
25 public:
26 virtual char Read(int number){
27
28 //额外的加密操作...
29 stream -> Read(number);//改用字段方式调用Read()
30 //... seek() write() 同理
31 }
32 }
2）考察上述2行， 13行， 24行， 发现其均为Stream子类， 应使用多态性继续重构。
1 class CryptoFileStream{
2 Stream* stream; // = new FileStream()
3 public:
4 virtual char Read(int number){
5
6 //额外的加密操作...
7 stream -> Read(number);//改用字段方式调用Read()
8 // ...seek() write() 同理
9 }
10 }
11
12 class CryptoNetworkStream{
13 Stream* stream; // = new NetworkStream();
14 public:
15 virtual char Read(int number){
16
17 //额外的加密操作...
18 stream -> Read(number);//改用字段方式调用Read()
19 //... seek() write() 同理
20 }
21 }
22
23 class CryptoMemoryStream{
24 Stream* stream; // = newMemoryStream()
25 public:
26 virtual char Read(int number){
27
28 //额外的加密操作...
29 stream -> Read(number);//改用字段方式调用Read()
30 //... seek() write() 同理
31 }
32 }
3）发现三个类是相同的，不同的实现（需求的变化）是在运行时实现，编译时复用，改为一个类即可，命名为CryptoStream。
同时为了保证接口规范（read,seek等仍然是虚函数），继承Stream,出现既有组合，又有继承的情况。
1 class CryptoStream : public Stream{
2 Stream* stream; // = new ...
3 public:
4 virtual char Read(int number){
5
6 //额外的加密操作...
7 stream -> Read(number);//改用字段方式调用Read()
8 // ...seek() write() 同理
9 }
10 }
4）添加相应构造器，得到此轮重构后的结果，代码如下，主要查看使用方式（运行时装配）：
1 //Decorator2.cpp
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 //主体类
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
57
58 class CryptoStream: public Stream {
59
60 Stream* stream;//...
61
62 public:
63 CryptoStream(Stream* stm):stream(stm){
64
65 }
66
67
68 virtual char Read(int number){
69
70 //额外的加密操作...
71 stream->Read(number);//读文件流
72 }
73 virtual void Seek(int position){
74 //额外的加密操作...
75 stream::Seek(position);//定位文件流
76 //额外的加密操作...
77 }
78 virtual void Write(byte data){
79 //额外的加密操作...
80 stream::Write(data);//写文件流
81 //额外的加密操作...
82 }
83 };
84
85
86
87 class BufferedStream : public Stream{
88
89 Stream* stream;//...
90
91 public:
92 BufferedStream(Stream* stm):stream(stm){
93
94 }
95 //...
96 };
97
98
99
100
101
102 void Process(){
103
104 //运行时装配
105 FileStream* s1=new FileStream();
106 CryptoStream* s2=new CryptoStream(s1);
107
108 BufferedStream* s3=new BufferedStream(s1);
109
110 BufferedStream* s4=new BufferedStream(s2);
111
112
113
114 }
实现代码3：
上述实现代码2已经极大地缓解了冗余问题，符合面向对象的设计思想，该轮重构是锦上添花。
重构步骤如下：
考察上述代码，多个子类都有同样的字段（Stream* stream;//...）
应考虑“往上提”，方法有两种，第一种是提到基类（显然不合适，FileStream等并不需要Stream字段 ）
所以考虑第二种方法，实现一个“中间类”。
DecoratorStream: public Stream{
protected:
Stream* stream;//...
DecoratorStream(Stream * stm):stream(stm){
}
};
CryptoStream等继承中间类DecoratorStream:
class CryptoStream: public DecoratorStream {
public:
CryptoStream(Stream* stm):DecoratorStream(stm){
}
//...
}
重构完成的最终版本：
FileStream,NetworkStream,MemoryStream等可以创建各自的对象；
但实现加密，缓存功能必须在已有FileStream/NetworkStream等对象基础上；
这些操作本质是扩展操作，也就是“装饰”的含义。
此时类图示意：
这时类的数量为（1 + n + 1 + m）
1 //Decorator3.cpp
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 //主体类
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
57 DecoratorStream: public Stream{
58 protected:
59 Stream* stream;//...
60
61 DecoratorStream(Stream * stm):stream(stm){
62
63 }
64
65 };
66
67 class CryptoStream: public DecoratorStream {
68
69
70 public:
71 CryptoStream(Stream* stm):DecoratorStream(stm){
72
73 }
74
75
76 virtual char Read(int number){
77
78 //额外的加密操作...
79 stream->Read(number);//读文件流
80 }
81 virtual void Seek(int position){
82 //额外的加密操作...
83 stream::Seek(position);//定位文件流
84 //额外的加密操作...
85 }
86 virtual void Write(byte data){
87 //额外的加密操作...
88 stream::Write(data);//写文件流
89 //额外的加密操作...
90 }
91 };
92
93
94
95 class BufferedStream : public DecoratorStream{
96
97 Stream* stream;//...
98
99 public:
100 BufferedStream(Stream* stm):DecoratorStream(stm){
101
102 }
103 //...
104 };
105
106
107
108
109 void Process(){
110
111 //运行时装配
112 FileStream* s1=new FileStream();
113
114 CryptoStream* s2=new CryptoStream(s1);
115
116 BufferedStream* s3=new BufferedStream(s1);
117
118 BufferedStream* s4=new BufferedStream(s2);
119
120
121
122 }
Decorator模式使用动机：
在某些情况下我们可能会“过度地使用继承来扩展对象的功能”，由于基础为类型引入的静态特指，使得这种扩展方式缺乏灵活性；并且随着子类的增多（扩展功能的增多），各个子类的组合（扩展功能的组合）会导致各种子类的膨胀。
模式定义：
动态（组合）地给一个对象增加一些额外的指责。就增加功能而言，Decorator模式比声场子类（继承）更为灵活（消除重复代码&减少子类个数）
类图：
要点总结：
1.通过采用组合并非继承的手法，Decorator模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的”灵活性差“和”多子类衍生问题“
2.Decorator类在接口上表现为is-a Component的继承关系，即Decorator类继承了Component类所具有的接口。但在实现上又表现为has-a Component的组合关系，即Decorator类又使用了另外一个Component类。
3.Decorator模式的目的并非解决”多字类衍生的多继承“问题，Decorator模式应用的要点在于解决”主体类在多个方向上的扩展功能“（显然file,network与加密，缓冲是两种扩展方向） ——是为”装饰“的含义。
参考文献：
李建忠老师 《C++设计模式》网络课程
《设计模式:可复用面向对象软件的基础》
标签：查看 基础上 new char 代码 面向对象 技术分享 参考文献 本质
原文地址：http://www.cnblogs.com/yechanglv/p/6931016.html
