设计模式——6. 适配器模式

1. 说明

适配器模式（Adapter Pattern）是一种结构型设计模式，它用于将一个类的接口转换成客户端所期望的另一个接口，以便于两者之间的协同工作。适配器模式允许不兼容的接口之间能够协同工作，而无需修改现有的代码。

适配器模式通常涉及以下几个关键角色：

1. 目标接口（Target Interface）： 这是客户端所期望的接口，它定义了客户端与适配器进行交互的方法。客户端代码通过调用目标接口的方法来使用适配器。
2. 适配器（Adapter）： 适配器是实现目标接口的类，它包装了一个或多个被适配的对象。适配器的主要责任是将客户端的请求转发给被适配的对象，以便于客户端能够使用被适配对象的功能。
3. 被适配的类（Adaptee）： 这是适配器要包装的类，它拥有客户端所需的功能，但其接口与目标接口不兼容。

适配器模式主要用于以下情况：

• 现有接口不符合需求： 当现有的接口无法满足客户端的需求时，适配器模式可以提供一个中间层，将现有接口转换为客户端期望的接口。
• 兼容多个类： 当需要在多个类之间共享某一功能时，适配器模式可以用于统一接口，使得多个类都能使用该功能。
• 类库重用： 当需要使用一个已经存在的类库，但其接口与系统要求不匹配时，适配器模式可以将该类库适配到系统中。

适配器模式使得不同接口的类能够协同工作，而无需修改它们的源代码，从而提高了代码的可维护性和扩展性。这个模式经常在系统集成、接口转换和代码重用的场景中使用。

2. 使用的场景

适配器模式的使用场景包括但不限于以下情况：

1. 接口不兼容： 当需要使用的类或接口的现有实现与客户端的需求不兼容时，适配器模式可以用于将其转换成客户端所期望的接口，使得它们能够协同工作。
2. 类库的适配： 当使用第三方类库或模块时，它们的接口可能与当前系统的接口不匹配。适配器模式可以用来包装这些类库，以便它们能够与系统中的其他组件无缝协同工作。
3. 多接口统一： 当一个类需要实现多个接口，但不希望将这些接口的所有方法都包含在类中时，可以使用适配器模式将这些接口中的部分方法实现为空方法，以减少代码冗余。
4. 系统集成： 在系统集成过程中，不同系统或组件之间可能有不同的数据格式、通信协议等，适配器模式可用于将这些差异转换成一致的格式，以便数据交换和通信。
5. 类的复用： 当需要在不同的项目或模块中重用已有的类时，适配器模式可以帮助将这些类适配到新的项目或模块中，以便复用现有代码。
6. 功能扩展： 在不修改现有代码的情况下，通过创建适配器来扩展现有类的功能，以适应新的需求或新的功能接口。
7. 遗留系统升级： 当需要升级或维护遗留系统时，适配器模式可以用来适配旧的接口，以适应新的需求或新的技术标准。

总之，适配器模式在需要将不同接口或类协同工作、实现接口转换、类库适配、接口统一等情况下非常有用。它能够提高代码的灵活性、可维护性和可扩展性，同时降低了系统的耦合度。

3. 应用例子

以下是一个使用Python语言实现适配器模式的示例，假设我们有一个英国插头（UKPlug）和一个中国插座（ChineseSocket），它们的接口不兼容，我们需要一个适配器来使得英国插头能够插入中国插座并工作。

# 目标接口：中国插座
class ChineseSocket:
    def power_on(self, voltage):
        print(f"中国插座供电，电压：{voltage}V")

# 适配器：英国插头适配到中国插座
class UKToChineseAdapter(ChineseSocket):
    def __init__(self, uk_plug):
        self.uk_plug = uk_plug

    def power_on(self, voltage):
        # 英国插头需要转换电压，然后接入中国插座
        uk_voltage = self.uk_plug.get_uk_voltage()
        if uk_voltage == 220:
            print("英国插头电压合适，已经适配到中国插座")
            super().power_on(voltage)
        else:
            print("电压不符，无法适配到中国插座")

# 英国插头类
class UKPlug:
    def get_uk_voltage(self):
        return 220  # 英国插头电压为220V

# 客户端代码
if __name__ == "__main__":
    uk_plug = UKPlug()
    adapter = UKToChineseAdapter(uk_plug)
    adapter.power_on(220)  # 适配器将英国插头适配到中国插座并供电

在这个示例中：

• ChineseSocket 是目标接口，表示中国插座，它有一个 power_on 方法用于供电。
• UKPlug 是英国插头类，它有一个 get_uk_voltage 方法返回英国插头的电压。
• UKToChineseAdapter 是适配器类，它继承了目标接口 ChineseSocket，并包含一个英国插头对象。适配器的 power_on 方法将英国插头的电压转换后接入中国插座，以适配两者的接口不一致。
• 客户端代码创建了英国插头和适配器对象，然后使用适配器来将英国插头适配到中国插座并供电。

适配器模式允许英国插头与中国插座协同工作，而无需修改它们的接口，提供了接口转换的灵活性。这个模式常用于不同接口的类之间协同工作的场景。

4. 实现要素

适配器模式的实现要素包括以下几个部分：

1. 目标接口（Target Interface）： 这是客户端所期望的接口，定义了客户端与适配器进行交互的方法。客户端通过调用目标接口的方法来使用适配器。
2. 适配器（Adapter）： 适配器是实现目标接口的类，它包装了一个或多个被适配的对象。适配器的主要责任是将客户端的请求转发给被适配的对象，以便于客户端能够使用被适配对象的功能。
3. 被适配的类（Adaptee）： 这是适配器要包装的类，它拥有客户端所需的功能，但其接口与目标接口不兼容。

5. Java/golang/javascrip/C++ 等语言实现方式

5.1 Java实现

上述例子用Java语言实现示例如下：

// 目标接口：中国插座
interface ChineseSocket {
    void powerOn(int voltage);
}

// 适配器：英国插头适配到中国插座
class UKToChineseAdapter implements ChineseSocket {
    private UKPlug ukPlug;

    public UKToChineseAdapter(UKPlug ukPlug) {
        this.ukPlug = ukPlug;
    }

    @Override
    public void powerOn(int voltage) {
        int ukVoltage = ukPlug.getUKVoltage();
        if (ukVoltage == 220) {
            System.out.println("英国插头电压合适，已适配到中国插座");
            System.out.println("中国插座供电，电压：" + voltage + "V");
        } else {
            System.out.println("电压不符，无法适配到中国插座");
        }
    }
}

// 英国插头类
class UKPlug {
    public int getUKVoltage() {
        return 220; // 英国插头电压为220V
    }
}

// 客户端代码
public class AdapterPatternExample {
    public static void main(String[] args) {
        UKPlug ukPlug = new UKPlug();
        ChineseSocket chineseSocket = new UKToChineseAdapter(ukPlug);
        chineseSocket.powerOn(220); // 适配器将英国插头适配到中国插座并供电
    }
}

5.2 Golang实现

上述例子用golang实现示例如下：

package main

import (
        "fmt"
)

// 目标接口：中国插座
type ChineseSocket interface {
        PowerOn(voltage int)
}

// 适配器：英国插头适配到中国插座
type UKToChineseAdapter struct {
        ukPlug *UKPlug
}

func NewUKToChineseAdapter(ukPlug *UKPlug) *UKToChineseAdapter {
        return &UKToChineseAdapter{ukPlug}
}

func (a *UKToChineseAdapter) PowerOn(voltage int) {
        ukVoltage := a.ukPlug.GetUKVoltage()
        if ukVoltage == 220 {
                fmt.Println("英国插头电压合适，已适配到中国插座")
                fmt.Printf("中国插座供电，电压：%dV\n", voltage)
        } else {
                fmt.Println("电压不符，无法适配到中国插座")
        }
}

// 英国插头类
type UKPlug struct{}

func (p *UKPlug) GetUKVoltage() int {
        return 220 // 英国插头电压为220V
}

// 客户端代码
func main() {
        ukPlug := &UKPlug{}
        adapter := NewUKToChineseAdapter(ukPlug)
        adapter.PowerOn(220) // 适配器将英国插头适配到中国插座并供电
}

5.3 Javascript实现

上述例子用javascript实现示例如下：

// 目标接口：中国插座
class ChineseSocket {
  powerOn(voltage) {
    console.log(`中国插座供电，电压：${voltage}V`);
  }
}

// 适配器：英国插头适配到中国插座
class UKToChineseAdapter extends ChineseSocket {
  constructor(ukPlug) {
    super();
    this.ukPlug = ukPlug;
  }

  powerOn(voltage) {
    const ukVoltage = this.ukPlug.getUKVoltage();
    if (ukVoltage === 220) {
      console.log("英国插头电压合适，已适配到中国插座");
      super.powerOn(voltage);
    } else {
      console.log("电压不符，无法适配到中国插座");
    }
  }
}

// 英国插头类
class UKPlug {
  getUKVoltage() {
    return 220; // 英国插头电压为220V
  }
}

// 客户端代码
const ukPlug = new UKPlug();
const adapter = new UKToChineseAdapter(ukPlug);
adapter.powerOn(220); // 适配器将英国插头适配到中国插座并供电

5.4 C++实现

上述例子用C++实现如下：

#include <iostream>

// 目标接口：中国插座
class ChineseSocket {
public:
    virtual void powerOn(int voltage) {
        std::cout << "中国插座供电，电压：" << voltage << "V" << std::endl;
    }
};

// 适配器：英国插头适配到中国插座
class UKToChineseAdapter : public ChineseSocket {
private:
    class UKPlug {
    public:
        int getUKVoltage() {
            return 220; // 英国插头电压为220V
        }
    };

    UKPlug* ukPlug;

public:
    UKToChineseAdapter(UKPlug* plug) : ukPlug(plug) {}

    void powerOn(int voltage) override {
        int ukVoltage = ukPlug->getUKVoltage();
        if (ukVoltage == 220) {
            std::cout << "英国插头电压合适，已适配到中国插座" << std::endl;
            ChineseSocket::powerOn(voltage);
        } else {
            std::cout << "电压不符，无法适配到中国插座" << std::endl;
        }
    }
};

int main() {
    UKToChineseAdapter::UKPlug ukPlug;
    UKToChineseAdapter adapter(&ukPlug);
    adapter.powerOn(220); // 适配器将英国插头适配到中国插座并供电
    return 0;
}

7. 练习题

假设你正在开发一个音频播放器应用程序，该应用程序能够播放不同格式的音频文件。你已经实现了一个音频播放器类 AudioPlayer，它可以播放MP3格式的音频文件。然而，现在你需要扩展该播放器以支持播放其他格式的音频文件，如MP4和VLC。

要求：

1. 使用适配器模式扩展 AudioPlayer 类，使其能够播放MP4和VLC格式的音频文件，而不需要修改现有的 AudioPlayer 类。
2. 创建适配器类，分别适配MP4和VLC格式的音频文件，以便它们可以与 AudioPlayer 协同工作。
3. 编写客户端代码，演示如何使用适配器模式来播放不同格式的音频文件。

这个练习题可以帮助你理解适配器模式如何用于将不同接口的音频文件适配到同一个播放器接口，从而实现了不同格式音频的播放。你需要设计适配器类，使其能够将不同格式的音频文件适配到 AudioPlayer 类的接口，而无需修改 AudioPlayer 类本身。

你可以在评论区里或者私信我回复您的答案，这样我或者大家都能帮你解答，期待着你的回复~