设计模式(七)——适配器模式
一、适配器模式简介
1、适配器模式简介
适配器模式用于将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的类可以一起工作。
适配器模式分为类适配器模式和对象适配器模式。
类适配器模式UML图:
类适配器模式用一个具体的Adapter类对Adaptee和Target进行匹配。但当想要匹配一个类及其所有的子类时,Adapter类将不能胜任工作。Adapter可以重定义Adaptee的部分行为,因为Adapter是Adaptee的一个子类。
对象适配器模式UML图:
允许一个Adapter与多个Adaptee,即Adaptee本身及其所有子类同时工作。Adapter也可以一次给所有的Adaptee添加功能。重定义Adaptee的行为比较困难,需要生成Adaptee的子类并且使得Adapter引用子类而不是引用Adaptee本身。
client需要request()函数,Adaptee提供的是specificRequest()函数,Adapter提供一个request()函数将Adaptee和SpecificeRequest()函数封装起来。
2、适配器模式角色
Target:客户所期待的接口,Target可以是具体的或抽象的类,也可以是接口。
Adaptee:需要适配的类,源接口。
Adapter:通过在内部包装一个Adaptee对象,把源接口转换成目标接口。
3、适配器模式优缺点
类适配器优点:
A、Adapter可以重定义Adaptee的部分行为
B、不需要额外的指针以间接得到Adaptee
类适配器缺点:
当想要匹配一个类及其所有子类时,类Adapter将无法实现。
对象适配器优点:
一个Adapter可以与多个Adaptee及其所有子类同时工作
对象适配器缺点:
不能重定义Adaptee的行为
4、适配器模式使用场景
适配器模式使用场景:
A、系统的数据和行为都正确,但接口不符时,应该考虑使用适配器,目的是使控制范围之外的一个原有对象与某个接口匹配。适配器模式主要应用于希望复用一些现存的类,但是接口又与复用环境要求不一致的情况。
B、想使用一个已经存在的类,但如果类的接口和要求的不相同时,就应该考虑用适配器模式。
C、购买的第三方开发组件,组件接口与自己系统的接口不相同,或者由于某种原因无法直接调用第三方组件,可以考虑适配器。
D、要在双方都不太容易修改的时候再使用适配器模式适配,而不是一有不同是就使用适配器模式。
二、适配器模式实现
Target目标接口类:#ifndef TARGET_H
#define TARGET_H
#include
using namespace std;
//目标接口类,客户期盼的接口
class Target
{
public:
Target(){}
virtual ~Target(){}
virtual void request()//定义标准接口
{
cout <
}
};
#endif // TARGET_H
AdapterClass类模式适配器类:#ifndef ADAPTERCLASS_H
#define ADAPTERCLASS_H
#include "Target.h"
#include "Adaptee.h"
//类模式适配类,通过public继承获得接口继承的效果,通过private继承获得实现继承的效果
class AdapterClass : public Target,private Adaptee
{
public:
AdapterClass(){}
~AdapterClass(){}
virtual void request()//实现Target定义的request接口
{
cout <
//在标准接口中调用要适配类的接口
specificRequest();
}
};
#endif // ADAPTERCLASS_H
AdapterObject对象适配器类:#ifndef ADAPTEROBJECT_H
#define ADAPTEROBJECT_H
#include "Target.h"
#include "Adaptee.h"
//对象适配器模式类,继承Target类,采用组合的方式实现Adaptee的复用
class AdapterObject : public Target
{
public:
AdapterObject(){}
AdapterObject(Adaptee* adaptee)
{
m_adaptee = new Adaptee();
}
~AdapterObject(){}
virtual void request()//实现Target定义的Request接口
{
cout <
//在标准接口中调用要适配类的接口
m_adaptee->specificRequest();
}
private:
Adaptee* m_adaptee;
};
#endif // ADAPTEROBJECT_H
Adaptee适配接口类:#ifndef ADAPTEE_H
#define ADAPTEE_H
#include
using namespace std;
//需要适配的接口
class Adaptee
{
public:
Adaptee(){}
~Adaptee(){}
void specificRequest()//需要适配接口
{
cout <
}
};
#endif // ADAPTEE_H
客户调用程序:#include
#include "AdapterClass.h"
#include "AdapterObject.h"
using namespace std;
int main()
{
//类模式适配器
Target* targetclass = new AdapterClass();
targetclass->request();
//对象模式适配器
Target* targetobject = new AdapterObject();
targetobject->request();
return 0;
}
在适配器模式的两种模式中,接口继承和实现继承的是重要的概念。
接口继承和实现继承是面向对象领域的两个重要的概念,接口继承指的是通过继承,子类获得了父类的接口;而实现继承指的是通过继承,子类获得了父类的实现(并不提供接口)。
在C++中的public继承既是接口继承又是实现继承,因为子类在继承了父类后既可以对外提供父类中的接口操作,又可以获得父类的接口实现。
通过private继承可以获得实现继承的效果。private继承后,父类中的接口都变为private,只能是实现继承)。通过纯抽象基类可以获得接口继承的效果,但在C++中纯虚函数也可以提供默认实现,因此是不纯正的接口继承,但是在Java中可以interface来获得真正的接口继承。
三、适配器模式实例
适配器模式将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 STL实现了一种数据结构,称为双端队列(deque),支持前后两段的插入与删除。STL实现栈和队列时,没有从头开始定义栈和队列,而是直接使用双端队列实现。栈和队列扮演了适配器的角色,队列用到了双端队列后端插入、前端删除,而栈用到了双端队列的后端插入、后端删除。假设栈和队列都是一种顺序容器,有两种操作:压入和弹出。
UML图如下:
Sequence目标接口:#ifndef SEQUENCE_H
#define SEQUENCE_H
//顺序容器,Target目标接口
class Sequence
{
public:
virtual void push(int x) = 0;
virtual void pop() = 0;
};
#endif // SEQUENCE_H
Queue适配器类:#ifndef QUEUE_H
#define QUEUE_H
#include "Sequence.h"
#include "Deque.h"
//队列,适配器
class Queue : public Sequence
{
public:
Queue(Deque* deque)
{
m_deque = deque;
}
void push(int x)
{
m_deque->push_back(x);
}
void pop()
{
m_deque->pop_front();
}
private:
Deque* m_deque;
};
#endif // QUEUE_H
Stack适配器类:#ifndef STACK_H
#define STACK_H
#include "Sequence.h"
#include "Deque.h"
//栈,适配器
class Stack : public Sequence
{
public:
Stack(Deque* deque)
{
m_deque = deque;
}
void push(int x)
{
m_deque->push_back(x);
}
void pop()
{
m_deque->pop_back();
}
private:
Deque* m_deque;
};
#endif // STACK_H
Deque源接口:#ifndef DEQUE_H
#define DEQUE_H
#include
using namespace std;
//双端队列,Adaptee源接口
class Deque
{
public:
void push_back(int x)
{
cout<
}
void push_front(int x)
{
cout<
}
void pop_back()
{
cout<
}
void pop_front()
{
cout<
}
};
#endif // DEQUE_H
客户端调用程序:#include "Sequence.h"
#include "Deque.h"
#include "Queue.h"
#include "Stack.h"
int main()
{
Deque *deque = new Deque();
Sequence* sequence1 = new Queue(deque);
sequence1->push(10);
sequence1->pop();
Sequence* sequence2 = new Stack(deque);
sequence2->push(20);
sequence2->pop();
delete sequence1,sequence2,deque;
return 0;
}