09. 适配器模式

一、适配器模式

在适配器模式（Adapter Pattern）中引入了一个被称为适配器（Adapter）的包装类，而它所包装的对象称为适配者（Adaptee），即被适配的类。适配器的实现就是把客户类的请求转化为对适配者的相应接口的调用，而无须修改原来的适配者接口和抽象目标类接口。也就是说：当客户类调用适配器的方法时，在适配器类的内部将调用适配者类的方法，而这个过程对客户类是透明的，客户类并不直接访问适配者类。因此，适配器让那些由于接口不兼容而不能交互的类可以一起工作。

适配器模式的主要角色包括：

目标抽象类（Target）：目标抽象类定义客户所需接口，可以是一个抽象类或接口，也可以是具体类。
适配器（Adapter）：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。
适配者（Adaptee）：被适配的角色，它定义了一个已经存在的接口，这个接口需要适配。适配者类一般是一个具体类，包含了客户希望使用的业务方法，在某些情况下可能没有适配者类的源代码。

在适配器模式中，通过增加一个新的适配器类来解决接口不兼容的问题，使得原本没有任何关系的类可以协同工作。根据适配器类与适配者类的关系不同，适配器模式可分为 对象适配器模式 和 类适配器模式 两种。

对象适配器模式：适配器与适配者之间是 关联关系。在这种形式中，适配器同时继承自源角色和实现目标接口，从而在适配器内部实现接口的转换。
类适配器模式：，适配器与适配者之间是 继承（或实现）关系。在这种形式中，适配器持有一个源角色的实例，并实现目标接口。当客户端调用适配器的方法时，适配器会将这些调用转换为对源角色实例的相应方法调用。

二、C++实现适配器模式

2.1、类适配器

类适配器模式

目标抽象类定义客户所需接口。

// 目标类
class SDCardInterface 
{
private:
    std::string data;

public:
    virtual std::string readSDCard(void) = 0;
    virtual void writeSDCard(std::string data) = 0;

    std::string getData(void);
    void setData(std::string data);
};

std::string SDCardInterface::getData(void)
{
    return data;
}

void SDCardInterface::setData(std::string data)
{
    this->data = data;
}

class SDCard : public SDCardInterface
{
public:
    std::string readSDCard(void) override;
    void writeSDCard(std::string data) override;
};

std::string SDCard::readSDCard(void)
{
    std::cout << "SDCard::read()" << std::endl;
    return getData();
}

void SDCard::writeSDCard(std::string data)
{
    std::cout << "SDCard::write()" << std::endl;
    setData(data);
}

适配者是被适配的角色，它定义了一个已经存在的接口，这个接口需要适配。

// 适配者类
class TFCardInterface 
{
private:
    std::string data;

public:
    virtual std::string readTFCard(void) = 0;
    virtual void writeTFCard(std::string data) = 0;

    std::string getData(void);
    void setData(std::string data);
};

std::string TFCardInterface::getData(void)
{
    return data;
}

void TFCardInterface::setData(std::string data)
{
    this->data = data;
}

class TFCard : public TFCardInterface
{
public:
    std::string readTFCard(void) override;
    void writeTFCard(std::string data) override;
};

std::string TFCard::readTFCard(void)
{
    std::cout << "TFCard::read()" << std::endl;
    return getData();
}

void TFCard::writeTFCard(std::string data)
{
    std::cout << "TFCard::write()" << std::endl;
    setData(data);
}

适配器类是一个转换器，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。适配器类实现了抽象目标类接口 Target，并继承了适配者类。

class SDAdapterTF : public SDCardInterface, public TFCard
{
public:
    std::string readSDCard(void);
    void writeSDCard(std::string data);
};

std::string SDAdapterTF::readSDCard(void)
{
    std::cout << "SDAdapterTF::read()" << std::endl;
    return readTFCard();
}

void SDAdapterTF::writeSDCard(std::string data)
{
    std::cout << "SDAdapterTF::write()" << std::endl;
    writeTFCard(data);
}

客户端：

class Computer
{
public:
    std::string readSDCard(SDCardInterface * sdCard);
    void writeSDCard(SDCardInterface * sdCard, std::string data);
};

std::string Computer::readSDCard(SDCardInterface * sdCard)
{
    return sdCard->readSDCard();
}

void Computer::writeSDCard(SDCardInterface * sdCard, std::string data)
{  
    sdCard->writeSDCard(data);
}

main() 函数：

#include <iostream>

int main(void)
{
    Computer computer;
    SDCard sdCard;
    SDAdapterTF sdAdapterTF;

    computer.writeSDCard(&sdCard, "Hello World!");
    std::cout << computer.readSDCard(&sdCard) << std::endl << std::endl;

    computer.writeSDCard(&sdAdapterTF, "Hello Sakura!");
    std::cout << computer.readSDCard(&sdAdapterTF) << std::endl;
  
    return 0;
}

这里，我们使用的是类适配器。类适配器违背了合成复用原则，类适配器是客户类有一个接口规范的情况可用，反之不可用。

2.2、对象适配器

对象适配器模式可采用将现有组件库中已经实现的组件引入适配器类中，该类同时实现当前系统的业务接口。

对象适配器模式

适配器类修改如下：

class SDAdapterTF : public SDCardInterface
{
private:
    TFCard * tfCard;

public:
    SDAdapterTF(void);
    SDAdapterTF(TFCard * tfCard);

    std::string readSDCard(void);
    void writeSDCard(std::string data);

    TFCard * getTFCard(void);
    void setTFCard(TFCard * tfCard);
};

SDAdapterTF::SDAdapterTF(void) {}
SDAdapterTF::SDAdapterTF(TFCard * tfCard) : tfCard(tfCard) {}

std::string SDAdapterTF::readSDCard(void)
{
    std::cout << "SDAdapterTF::read()" << std::endl;
    return tfCard->readTFCard();
}

void SDAdapterTF::writeSDCard(std::string data)
{
    std::cout << "SDAdapterTF::write()" << std::endl;
    tfCard->writeTFCard(data);
}

TFCard * SDAdapterTF::getTFCard(void)
{
    return tfCard;
}

void SDAdapterTF::setTFCard(TFCard * tfCard)
{
    this->tfCard = tfCard;
}

main() 函数：

#include <iostream>

int main(void)
{
    Computer computer;
    SDCard sdCard;
    TFCard tfCard;
    SDAdapterTF sdAdapterTF(&tfCard);

    computer.writeSDCard(&sdCard, "Hello World!");
    std::cout << computer.readSDCard(&sdCard) << std::endl << std::endl;

    computer.writeSDCard(&sdAdapterTF, "Hello Sakura!");
    std::cout << computer.readSDCard(&sdAdapterTF) << std::endl;
  
    return 0;
}

2.3、缺省适配器模式

缺省适配器模式 是适配器模式的一种变体。在这种模式中，适配器是由一个抽象类实现的，该抽象类实现了目标接口中规定的所有方法，但很多方法的实现都是空方法（即平庸实现）。具体的子类继承此抽象类后，只需覆盖其感兴趣的方法即可。总的来说，适配器模式是一种非常灵活且实用的设计模式，它能够在不修改现有类结构的情况下实现接口的转换和功能的兼容，从而降低系统的维护成本和扩展难度。

三、适配器模式的总结

3.1、适配器模式的优点

无论是对象适配器模式还是类适配器模式都具有如下优点：

将目标类和适配者类解耦。通过引入一个适配器类来重用现有的适配者类，无须修改原有结构。
增加了类的透明性和复用性。将具体的业务实现过程封装在适配者类中，对于客户端类而言是透明的，而且提高了适配者类的复用性，同一个适配者类可以在多个不同的系统中复用。
灵活性和扩展性都非常好。通过使用配置文件，可以很方便地更换适配器，也可以在不修改原有代码的基础上增加新的适配器类，完全符合开闭原则。

具体来说，类适配器模式 还有这样的优点：由于适配器类是适配者类的子类，因此可以在适配器类中置换一些适配者的方法，使得适配器的灵活性更强。

对象适配器模式还有如下优点：

一个对象适配器可以把多个不同的适配者适配到同一个目标。
可以适配一个适配者的子类。由于适配器和适配者之间是关联关系，根据里氏代换原则，适配者的子类也可通过该适配器进行适配。

3.2、适配器模式的缺点

类适配器模式的缺点如下：

对于 Java、C# 等不支持多重类继承的语言，一次最多只能适配一个适配者类，不能同时适配多个适配者。
适配者类不能为最终类，例如在 Java、C++ 中不能为 final 类，C# 中不能为 sealed 类。
在 Java、C# 等语言中，类适配器模式中的目标抽象类只能为接口，不能为类，其使用有一定的局限性。

对象适配器模式的缺点是：与类适配器模式相比，要在适配器中置换适配者类的某些方法比较麻烦。如果一定要置换掉适配者类的一个或多个方法，可以先做一个适配者类的子类，在子类中将适配者类的方法置换掉，然后再把适配者类的子类当作真正的适配者进行适配，实现过程较为复杂。

3.3、适配器模式的适用场景

系统需要使用一些现有的类，而这些类的接口（例如方法名）不符合系统的需要，甚至没有这些类的源代码。
想创建一个可以重复使用的类，用于与一些彼此之间没有太大关联的类，包括一些可能在将来引进的类一起工作。

posted @ 2023-09-01 18:47 星光映梦阅读(12) 评论(0) 编辑收藏举报

刷新页面返回顶部

FlurryHeart