设计模式 --> （5）适配器模式

适配器模式

　　适配器模式把一个类的接口变换成客户端所期待的另一种接口，从而使原本接口不匹配而无法在一起工作的两个类能够在一起工作。比如说我的hp笔记本，美国产品，人家美国的电压是110V的，而我们中国的电压是220V，要在中国能使用，必须找个变压器转一下电压才可以。这个变压器就是个适配器。

适配器模式有类适配器和对象适配器两种模式。

适用性：

　　使用第三方库的时候，第三方的库肯定不能适用所有的系统，所以需要一个适配器来转换。

优点：

　　1.屏蔽了具体的实现方式，实现了依赖倒转。

　　2.可以把不统一的接口封装起来，使之成为统一的接口。

　　3.把本来不方便适用的接口转换成统一的接口。

类适配器

　　为了使客户能够使用Adaptee类，提供一个中间环节，即类Adapter类，Adapter类实现了Target接口，并继承自Adaptee，Adapter类的Request方法重新封装了Adaptee的SpecificRequest方法，实现了适配的目的。

因为Adapter与Adaptee是继承的关系，所以这决定了这个适配器模式是类的。

目标（Target）角色： 这是客户所期待的接口。因为C#不支持多继承，所以Target必须是接口，不可以是类。

源（Adaptee）角色： 需要适配的类。

适配器（Adapter）角色： 把源接口转换成目标接口。这一角色必须是类。

实现：

#include<iostream>  
using namespace std;  
  
// 目标接口类，客户需要的接口 
class Target  
{  
public:  
    virtual void Request(){};  
};  
  
// 需要适配的类 
class Adaptee  
{  
public:  
    void SpecificRequest()  
    {  
        cout<<"Called SpecificRequest()"<<endl;  
    }  
};  
  
//类模式，适配器类，通过public继承获得接口继承的效果
class Adapter : public Adaptee, public Target  
{  
public:  
    void Request()  
    {    
        this->SpecificRequest();  
    }  
};  
  
int main()  
{  
    Target *t = new Adapter();  
    t->Request(); 
    
    if(t) delete t;
    return 0;  
} 

对象适配器

　　客户端需要调用Request方法，而Adaptee没有该方法，为了使客户端能够使用Adaptee类，需要提供一个包装（Wrapper）类Adapter。这个包装类包装了一个Adaptee的实例，从而将客户端与Adaptee衔接起来。

由于Adapter与Adaptee是委派关系，这决定了这个适配器模式是对象的。

目标（Target）角色：这是客户所期待的接口。目标可以是具体的或抽象的类，也可以是接口。

源（Adaptee）角色：需要适配的类。

适配器（Adapter）角色：通过在内部包装（Wrap）一个Adaptee对象，把源接口转换成目标接口。

实现：

#include<iostream>
using namespace std;

// 目标接口类，客户需要的接口 
class Target
{
public:
    // Methods
    virtual void Request(){};
};

// 需要适配的类 
class Adaptee
{
public:
    // Methods
    void SpecificRequest()
    {
        cout<<"Called SpecificRequest()"<<endl;
    }
};

// 类模式，适配器类，通过public继承获得接口继承的效果
class Adapter : public Target
{
private:
    Adaptee *adaptee;

public:
    Adapter()
    {
        adaptee = new Adaptee();
    }
    void Request()
    { 
        adaptee->SpecificRequest();
    }
};

int main()
{
    Target *t = new Adapter();
    t->Request();

    if(t) delete t; 
    return 0;
}

队列适配器

下面例子便于理解，可参考（http://blog.csdn.net/wuzhekai1985/article/details/6665542）

#include <iostream>
#include <deque>
using namespace std;

//双端队列  
class Deque  
{  
public:  
    void push_back(int x) { cout<<"Deque push_back"<<endl; }  
    void push_front(int x) { cout<<"Deque push_front"<<endl; }  
    void pop_back() { cout<<"Deque pop_back"<<endl; }  
    void pop_front() { cout<<"Deque pop_front"<<endl; }  
};  
//顺序容器  
class Sequence  
{  
public:  
    virtual void push(int x) = 0;  
    virtual void pop() = 0;  
};  
//栈  
class Stack: public Sequence  
{  
public:  
    void push(int x) { deque.push_back(x); }  
    void pop() { deque.pop_back(); }  
private:  
    Deque deque; //双端队列  
};  
//队列  
class Queue: public Sequence  
{  
public:  
    void push(int x) { deque.push_back(x); }  
    void pop() { deque.pop_front(); }  
private:  
    Deque deque; //双端队列  
};  

int main()  
{  
    Sequence *s1 = new Stack();  
    Sequence *s2 = new Queue();  
    s1->push(1); s1->pop();  
    s2->push(1); s2->pop();  
    delete s1; delete s2;  
    return 0;  
}  

实现要点

　　1．Adapter模式主要应用于“希望复用一些现存的类，但是接口又与复用环境要求不一致的情况”，在遗留代码复用、类库迁移等方面非常有用。

　　2．Adapter模式有对象适配器和类适配器两种形式的实现结构，但是类适配器采用“多继承”的实现方式，带来了不良的高耦合，所以一般不推荐使用。对象适配器采用“对象组合”的方式，更符合松耦合精神。

　　3．Adapter模式的实现可以非常的灵活，不必拘泥于GOF23中定义的两种结构。例如，完全可以将Adapter模式中的“现存对象”作为新的接口方法参数，来达到适配的目的。

　　4．Adapter模式本身要求我们尽可能地使用“面向接口的编程”风格，这样才能在后期很方便的适配。

适用性

在以下各种情况下使用适配器模式：

　　1．系统需要使用现有的类，而此类的接口不符合系统的需要。

　　2．想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作。这些源类不一定有很复杂的接口。

　　3．（对对象适配器而言）在设计里，需要改变多个已有子类的接口，如果使用类的适配器模式，就要针对每一个子类做一个适配器，而这不太实际。

参考：http://blog.csdn.net/wuzhekai1985