设计模式（七）——适配器模式

设计模式（七）——适配器模式

一、适配器模式简介

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 << "Target::request()" << endl;
    }
};
 
#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 << "AdapterClass::request()" << endl;
        //在标准接口中调用要适配类的接口
        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 << "AdapterObject::request()" << endl;
        //在标准接口中调用要适配类的接口
        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 << "Adaptee::specificRequest()" << endl;
    }
};
 
#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<<"Deque push_back"< 
  

 
  
客户端调用程序：
 
  
#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;
}