单一职责模式概念
- 在软件组件的设计中，如果责任划分的不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。
1、装饰着模式（Decorator）
动机（Motivation)
- 在某些情况下我们可能会
“过度地使用继承来扩展对象的功能”，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多(扩展功能的增多)，各种子类的组合（扩展功能的组合)会导致更多子类的膨胀。 - 如何使“对象功能的扩展”能够根据需要来动态地实现?同时避免“扩展功能的增多"带来的子类膨胀问题？从而使得任何“功能扩展变化"所导致的影响将为最低?
模式定义
- 动态（组合)地给一个对象增加一些额外的职责。就增加功能而言，Decorator模式比生成子类（继承）更为灵活（消除重复代码&减少子类个数)。
代码具体实现
- 介绍一个代码急剧膨胀的结构图
class Stream{
public：
virtual char Read(int number)=0;
virtual void Seek(int position)=0;
virtual void Write(char data)=0;
virtual ~Stream(){}
};
class FileStream: public Stream{
public:
virtual char Read(int number){
}
virtual void Seek(int position){
}
virtual void Write(char data){
}
};
class NetworkStream :public Stream{
public:
virtual char Read(int number){
}
virtual void Seek(int position){
}
virtual void Write(char data){
}
};
class MemoryStream :public Stream{
public:
virtual char Read(int number){
}
virtual void Seek(int position){
}
virtual void Write(char data){
}
};
class CryptoFileStream :public FileStream{
public:
virtual char Read(int number){
FileStream::Read(number);
}
virtual void Seek(int position){
FileStream::Seek(position);
}
virtual void Write(byte data){
FileStream::Write(data);
}
};
class CryptoNetworkStream : :public NetworkStream{
public:
virtual char Read(int number){
NetworkStream::Read(number);
}
virtual void Seek(int position){
NetworkStream::Seek(position);
}
virtual void Write(byte data){
NetworkStream::Write(data);
}
};
class CryptoMemoryStream : public MemoryStream{
public:
virtual char Read(int number){
MemoryStream::Read(number);
}
virtual void Seek(int position){
MemoryStream::Seek(position);
}
virtual void Write(byte data){
MemoryStream::Write(data);
}
};
class BufferedFileStream : public FileStream{
};
class BufferedNetworkStream : public NetworkStream{
};
class BufferedMemoryStream : public MemoryStream{
}
class CryptoBufferedFileStream :public FileStream{
public:
virtual char Read(int number){
FileStream::Read(number);
}
virtual void Seek(int position){
FileStream::Seek(position);
}
virtual void Write(byte data){
FileStream::Write(data);
}
};
void Process(){
CryptoFileStream *fs1 = new CryptoFileStream();
BufferedFileStream *fs2 = new BufferedFileStream();
CryptoBufferedFileStream *fs3 =new CryptoBufferedFileStream();
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 不难发现上面代码中出现很多
重复代码的部分，就是名字不同，这个时候增加基类的指针将编译时装配变成运行时装配
- 修改代码成装配者模式，将增加一个基类指针实现多态减少继承的使用而去增加组合，去掉重复代码，并且将重复代码往上提，新建装饰者类。
class Stream{
public：
virtual char Read(int number)=0;
virtual void Seek(int position)=0;
virtual void Write(char data)=0;
virtual ~Stream(){}
};
class FileStream: public Stream{
public:
virtual char Read(int number){
}
virtual void Seek(int position){
}
virtual void Write(char data){
}
};
class NetworkStream :public Stream{
public:
virtual char Read(int number){
}
virtual void Seek(int position){
}
virtual void Write(char data){
}
};
class MemoryStream :public Stream{
public:
virtual char Read(int number){
}
virtual void Seek(int position){
}
virtual void Write(char data){
}
};
DecoratorStream: public Stream{
protected:
Stream* stream;
DecoratorStream(Stream * stm):stream(stm){
}
};
class CryptoStream: public DecoratorStream {
public:
CryptoStream(Stream* stm):DecoratorStream(stm){
}
virtual char Read(int number){
stream->Read(number);
}
virtual void Seek(int position){
stream::Seek(position);
}
virtual void Write(byte data){
stream::Write(data);
}
};
class BufferedStream : public DecoratorStream{
public:
BufferedStream(Stream* stm):DecoratorStream(stm){
}
};
void Process(){
FileStream* s1=new FileStream();
CryptoStream* s2=new CryptoStream(s1);
BufferedStream* s3=new BufferedStream(s1);
BufferedStream* s4=new BufferedStream(s2);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
要点总结
- 通过采用组合而非继承的手法，Decorator模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的“灵活性差”和“多子类衍生问题
- Decorator类在接口上表现为is-a Component的继承关系，即Decorator类继承了Component类所具有的接口。但在实现上又表现为has-a Component的组合关系，即Decorator类又使用了另外一个Component类。
- Decorator模式的目的并非解决“多子类衍生的多继承"问题，
Decorator模式应用的要点在于解决“主体类在多个方向上的扩展功能”——是为“装饰”的含义。
2、桥模式（Bridge）
动机 （Motivation)
- 由于某些类型的固有的实现逻辑，使得它们具有两个变化的维度，乃至多个纬度的变化。
- 如何应对这种“多维度的变化"？如何利用面向对象技术来使得类型可以轻松地沿着两个乃至多个方向变化，而不引入额外的复杂度？
模式定义
- 将抽象部分(业务功能)与实现部分(平台实现)分离，使它们都可以独立地变化。
代码具体实现
- 主要表现在需要这个基类其实可以拆开成两个基类，加入组合实现多态，这个实现的类数量为
n * m
class Messager{
public:
virtual void Login(string username, string password)=0;
virtual void SendMessage(string message)=0;
virtual void SendPicture(Image image)=0;
virtual void PlaySound()=0;
virtual void DrawShape()=0;
virtual void WriteText()=0;
virtual void Connect()=0;
virtual ~Messager(){}
};
class PCMessagerBase : public Messager{
public:
virtual void PlaySound(){
}
virtual void DrawShape(){
}
virtual void WriteText(){
}
virtual void Connect(){
}
};
class MobileMessagerBase : public Messager{
public:
virtual void PlaySound(){
}
virtual void DrawShape(){
}
virtual void WriteText(){
}
virtual void Connect(){
}
};
class PCMessagerLite : public PCMessagerBase {
public:
virtual void Login(string username, string password){
PCMessagerBase::Connect();
}
virtual void SendMessage(string message){
PCMessagerBase::WriteText();
}
virtual void SendPicture(Image image){
PCMessagerBase::DrawShape();
}
};
class PCMessagerPerfect : public PCMessagerBase {
public:
virtual void Login(string username, string password){
PCMessagerBase::PlaySound();
PCMessagerBase::Connect();
}
virtual void SendMessage(string message){
PCMessagerBase::PlaySound();
PCMessagerBase::WriteText();
}
virtual void SendPicture(Image image){
PCMessagerBase::PlaySound();
PCMessagerBase::DrawShape();
}
};
class MobileMessagerLite : public MobileMessagerBase {
public:
virtual void Login(string username, string password){
MobileMessagerBase::Connect();
}
virtual void SendMessage(string message){
MobileMessagerBase::WriteText();
}
virtual void SendPicture(Image image){
MobileMessagerBase::DrawShape();
}
};
class MobileMessagerPerfect : public MobileMessagerBase {
public:
virtual void Login(string username, string password){
MobileMessagerBase::PlaySound();
MobileMessagerBase::Connect();
}
virtual void SendMessage(string message){
MobileMessagerBase::PlaySound();
MobileMessagerBase::WriteText();
}
virtual void SendPicture(Image image){
MobileMessagerBase::PlaySound();
MobileMessagerBase::DrawShape();
}
};
void Process(){
Messager *m =
new MobileMessagerPerfect();
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 使用桥模式 ，衍生出的类的数目
n + m
class Messager{
protected:
MessagerImp* messagerImp;
public:
virtual void Login(string username, string password)=0;
virtual void SendMessage(string message)=0;
virtual void SendPicture(Image image)=0;
virtual ~Messager(){}
};
class MessagerImp{
public:
virtual void PlaySound()=0;
virtual void DrawShape()=0;
virtual void WriteText()=0;
virtual void Connect()=0;
virtual MessagerImp(){}
};
class PCMessagerImp : public MessagerImp{
public:
virtual void PlaySound(){
}
virtual void DrawShape(){
}
virtual void WriteText(){
}
virtual void Connect(){
}
};
class MobileMessagerImp : public MessagerImp{
public:
virtual void PlaySound(){
}
virtual void DrawShape(){
}
virtual void WriteText(){
}
virtual void Connect(){
}
};
class MessagerLite :public Messager {
public:
virtual void Login(string username, string password){
messagerImp->Connect();
}
virtual void SendMessage(string message){
messagerImp->WriteText();
}
virtual void SendPicture(Image image){
messagerImp->DrawShape();
}
};
class MessagerPerfect :public Messager {
public:
virtual void Login(string username, string password){
messagerImp->PlaySound();
messagerImp->Connect();
}
virtual void SendMessage(string message){
messagerImp->PlaySound();
messagerImp->WriteText();
}
virtual void SendPicture(Image image){
messagerImp->PlaySound();
messagerImp->DrawShape();
}
};
void Process(){
MessagerImp* mImp=new PCMessagerImp();
Messager *m =new Messager(mImp);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
要点总结
- Bridge模式使用“对象间的组合关系"解耦了抽象和实现之间固有的绑定关系，使得抽象和实现可以沿着各自的维度来变化。所谓抽象和实现沿着各自纬度的变化，即“子类化"它们。
- Bridge模式有时候类似于多继承方案，但是多继承方案往往违背单一职责原则（即一个类只有一个变化的原因，复用性较差。Bridge模式是比多继承方案更好的解决方法。
- Bridge模式的应用一般在“两个非常强的变化维度”，有时一个类也有多于两个的变化维度，这时可以使用Bridge的扩展模式。