设计模式——适配器模式

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了设计模式——适配器模式相关的知识,希望对你有一定的参考价值。

设计模式(七)——适配器模式

一、适配器模式简介

1、适配器模式简介

 适配器模式用于将一个类的接口转换成客户希望的另外一个接口使得原本由于接口不兼容而不能一起工作的类可以一起工作。

    适配器模式分为类适配器模式和对象适配器模式。

类适配器模式UML图:

技术分享

    类适配器模式用一个具体的Adapter类对AdapteeTarget进行匹配。当想要匹配一个类及所有的子类时,Adapter将不能胜任工作。
        Adapter可以重定义Adaptee的部分行为,因为AdapterAdaptee的一个子类。

对象适配器模式UML图:

技术分享

    允许一个Adapter与多个AdapteeAdaptee本身及其所有子类同时工作。Adapter也可以一次给所有的Adaptee添加功能。
重定义Adaptee的行为比较困难需要生成Adaptee的子类并且使得Adapter引用子类而不是引用Adaptee本身。

    client需要request()函数,Adaptee提供的是specificRequest()函数,Adapter提供一个request()函数将AdapteeSpecificeRequest()函数封装起来。

2、适配器模式角色

    Target:客户所期待的接口,Target可以是具体的或抽象的类,也可以是接口。

    Adaptee:需要适配的类,源接口

    Adapter:通过在内部包装一个Adaptee对象,把源接口转换成目标接口。

3、适配器模式优缺点

类适配器优点:

    AAdapter可以重定义Adaptee的部分行为

    B不需要额外的指针以间接得到Adaptee

类适配器缺点

    当想要匹配一个类及其所有子类时,类Adapter将无法实现

对象适配器优点

    一个Adapter可以与多个Adaptee及其所有子类同时工作

对象适配器缺点

    不能重定义Adaptee的行为

4、适配器模式使用场景

适配器模式使用场景:

 A系统的数据和行为都正确,但接口不符时,应该考虑使用适配器,目的是使控制范围之外的一个原有对象与某个接口匹配。适配器模式主要应用于希望复用一些现存的类,但是接口又与复用环境要求不一致的情况。

    B想使用一个已经存在的类,但如果的接口和要求不相同时,就应该考虑用适配器模式。

    C购买的第三方开发组件,组件接口与自己系统的接口不相同,或者由于某种原因无法直接调用第三方组件,可以考虑适配器。

    D要在双方都不太容易修改的时候再使用适配器模式适配,而不是一有不同是就使用适配器模式

二、适配器模式实现

Target目标接口类:

#ifndef TARGET_H

#define TARGET_H

#include <iostream>

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 <iostream>

using namespace std;

 

//需要适配的接口

class Adaptee

{

public:

    Adaptee(){}

    ~Adaptee(){}

    void specificRequest()//需要适配接口

    {

        cout << "Adaptee::specificRequest()" << endl;

    }

};

 

#endif // ADAPTEE_H

客户调用程序:

#include <iostream>

#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 <iostream>

using namespace std;

 

//双端队列,Adaptee源接口

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;

    }

};

 

#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;

}


本文出自 “生命不息,奋斗不止” 博客,谢绝转载!

以上是关于设计模式——适配器模式的主要内容,如果未能解决你的问题,请参考以下文章

尚硅谷设计模式学习 --- [类适配器模式对象适配器模式接口适配器模式]

设计模式——适配器模式

设计模式 结构型模式 -- 适配器模式(概述类适配器模式对象适配器模式适配器模式适用场景JDK源码解析(I / O流))

设计模式:适配器模式(Adapter)

设计模式之(20)——适配器模式

设计模式之各种适配器