第三部分：结构型模式 - 适配器模式 (Adapter Pattern)

欢迎来到结构型模式的第一站！结构型模式关注的是如何将类或对象组合成更大的结构，同时保持结构的灵活性和效率。适配器模式是其中非常实用的一个，它能帮助我们解决接口不兼容的问题。

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

适配器模式 (Adapter Pattern)

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

想象一下，你去国外旅行，你带的电器插头是两孔的，但酒店的插座是三孔的。这时你就需要一个“电源适配器”，它的一端可以插入三孔插座，另一端提供两孔插口，让你的电器能够正常工作。这个电源适配器就是“适配器模式”的体现。

1. 目的 (Intent)

适配器模式的主要目的：

1. 接口转换：核心目的是将一个已存在的类（被适配者 Adaptee）的接口转换成客户端所期望的另一个接口（目标接口 Target）。
2. 复用现有代码：使得客户端可以复用一些功能强大但接口不兼容的已有类。
3. 解耦：将客户端与被适配者解耦。客户端只需要与目标接口交互，而不需要知道被适配者的具体实现。

2. 生活中的例子 (Real-world Analogy)

• 电源适配器：如上所述，不同国家/地区的电源插座和电器插头标准不同，电源适配器可以转换它们，使其兼容。
• 读卡器：你的电脑可能只有USB接口，但你想读取SD卡或TF卡中的数据。读卡器就充当了适配器，将SD卡/TF卡的接口转换成USB接口，让电脑可以访问卡内数据。
• 翻译官：两个人说不同的语言（比如中文和英文），无法直接交流。翻译官（适配器）可以将一方的语言（中文）转换成另一方能理解的语言（英文），反之亦然，从而实现沟通。
• Java中的 Arrays.asList()：这个方法可以将一个数组转换成一个 List 对象。数组和 List 的操作接口不同，asList() 创建了一个适配器，使得你可以像操作 List 一样操作底层数组（但要注意这个 List 是固定大小的）。
• Java中的 InputStreamReader 和 OutputStreamWriter：它们是字节流和字符流之间的桥梁（适配器）。InputStreamReader 将字节输入流 InputStream 转换为字符输入流 Reader，OutputStreamWriter 将字符输出流 Writer 转换为字节输出流 OutputStream。

3. 结构 (Structure)

适配器模式主要有两种实现形式：类适配器和对象适配器。

a. 类适配器模式 (Class Adapter)

• 原理：通过类的继承来实现。适配器类继承了被适配者类，并同时实现了目标接口。
• 角色：
  1. Target (目标接口)：客户端期望的接口。可以是抽象类或接口。
  2. Adaptee (被适配者)：需要被适配的类，它拥有客户端需要的功能，但其接口与 Target 不兼容。
  3. Adapter (适配器)：继承 Adaptee 类并实现 Target 接口。它通过调用继承来的 Adaptee 的方法来完成 Target 接口定义的功能。
  4. Client (客户端)：通过 Target 接口与 Adapter 交互。
     

缺点：

• 由于适配器继承了被适配者，所以它不能再继承其他类（在单继承语言如Java中）。
• 适配器直接暴露了被适配者的方法（如果继承的是具体类而非接口），可能不符合最少知识原则。
• 只能适配一个被适配者类。

b. 对象适配器模式 (Object Adapter)

• 原理：通过对象的组合（关联）来实现。适配器类持有一个被适配者对象的引用，并实现了目标接口。
• 角色：
  1. Target (目标接口)：同上。
  2. Adaptee (被适配者)：同上。
  3. Adapter (适配器)：实现 Target 接口，并内部持有一个 Adaptee 对象的实例。在实现 Target 接口的方法时，它调用 Adaptee 实例的方法。
  4. Client (客户端)：同上。
     
     优点：
• 更灵活，因为适配器可以适配 Adaptee 的任何子类。
• 可以同时适配多个被适配者（如果需要，但不常见于标准适配器模式）。
• 符合合成复用原则。

推荐使用对象适配器模式，因为它更符合面向对象的设计原则，具有更好的灵活性和可扩展性。

4. 适用场景 (When to Use)

• 你想使用一个已经存在的类，而它的接口不符合你的需求。
• 你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。
• (仅用于对象适配器) 你想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。
• 系统集成：当需要集成一些第三方库或遗留系统，而它们的接口与当前系统不兼容时。
• 代码迁移：在逐步替换旧组件时，可以使用适配器来兼容新旧接口。

5. 优缺点 (Pros and Cons)

通用优点：

1. 提高类的复用性：可以复用现有的、接口不兼容的类。
2. 增加灵活性：客户端代码与具体实现解耦，可以方便地替换被适配者或适配器。
3. 透明性：客户端可以像使用其他符合目标接口的类一样使用适配器，无需关心适配过程。

类适配器的特定缺点：

1. 目标抽象类只能是接口，不能是类 (在Java等单继承语言中，如果Adapter已继承Adaptee)。
2. 不易于适配Adaptee的子类：因为Adapter已经继承了Adaptee。

对象适配器的特定优点：

1. 可以适配Adaptee的任何子类。
2. 更容易动态替换被适配对象。

通用缺点：

1. 增加了系统的复杂性：引入了额外的适配器类。
2. 可能降低性能：额外的间接调用可能会带来轻微的性能开销（通常可忽略不计）。

6. 实现方式 (Implementations)

我们以一个媒体播放器的例子来说明对象适配器模式。假设我们有一个通用的 MediaPlayer 接口，可以播放 mp3 文件。现在我们想让它也能播放 mp4 和 vlc 格式的文件，但我们有一个现成的 AdvancedMediaPlayer 接口及其实现类，它们可以播放这些高级格式，但接口与 MediaPlayer 不兼容。

目标接口 (MediaPlayer)

// media_player.go
package media

// MediaPlayer 目标接口
type MediaPlayer interface {
	Play(audioType string, fileName string)
}

// MediaPlayer.java
package com.example.media;

// 目标接口
public interface MediaPlayer {
   void play(String audioType, String fileName);
}

被适配者接口 (AdvancedMediaPlayer) 和实现

// advanced_media_player.go
package media

import "fmt"

// AdvancedMediaPlayer 被适配者接口
type AdvancedMediaPlayer interface {
	PlayMp4(fileName string)
	PlayVlc(fileName string)
}

// Mp4Player 具体被适配者
type Mp4Player struct{}

func (p *Mp4Player) PlayMp4(fileName string) {
	fmt.Println("Playing mp4 file. Name:", fileName)
}
func (p *Mp4Player) PlayVlc(fileName string) { /* 什么也不做 */ }

// VlcPlayer 具体被适配者
type VlcPlayer struct{}

func (p *VlcPlayer) PlayVlc(fileName string) {
	fmt.Println("Playing vlc file. Name:", fileName)
}
func (p *VlcPlayer) PlayMp4(fileName string) { /* 什么也不做 */ }

// AdvancedMediaPlayer.java
package com.example.media;

// 被适配者接口
public interface AdvancedMediaPlayer {
   void playMp4(String fileName);
   void playVlc(String fileName);
}

// Mp4Player.java
package com.example.media.advanced;

import com.example.media.AdvancedMediaPlayer;

public class Mp4Player implements AdvancedMediaPlayer {
    @Override
    public void playMp4(String fileName) {
        System.out.println("Playing mp4 file. Name: "+ fileName);
    }

    @Override
    public void playVlc(String fileName) {
        // do nothing
    }
}

// VlcPlayer.java
package com.example.media.advanced;

import com.example.media.AdvancedMediaPlayer;

public class VlcPlayer implements AdvancedMediaPlayer {
    @Override
    public void playMp4(String fileName) {
        // do nothing
    }

    @Override
    public void playVlc(String fileName) {
        System.out.println("Playing vlc file. Name: "+ fileName);
    }
}

适配器 (MediaAdapter)

// media_adapter.go
package media

// MediaAdapter 适配器 (对象适配器)
type MediaAdapter struct {
	advancedPlayer AdvancedMediaPlayer
}

func NewMediaAdapter(audioType string) *MediaAdapter {
	adapter := &MediaAdapter{}
	if audioType == "mp4" {
		adapter.advancedPlayer = &Mp4Player{}
	} else if audioType == "vlc" {
		adapter.advancedPlayer = &VlcPlayer{}
	}
	return adapter
}

func (ma *MediaAdapter) Play(audioType string, fileName string) {
	if ma.advancedPlayer == nil {
		fmt.Printf("MediaAdapter: Cannot play %s. Advanced player not initialized for this type.\n", audioType)
		return
	}
	if audioType == "mp4" {
		ma.advancedPlayer.PlayMp4(fileName)
	} else if audioType == "vlc" {
		ma.advancedPlayer.PlayVlc(fileName)
	}
}

// MediaAdapter.java
package com.example.media;

import com.example.media.advanced.Mp4Player;
import com.example.media.advanced.VlcPlayer;

// 适配器 (对象适配器)
public class MediaAdapter implements MediaPlayer {

   AdvancedMediaPlayer advancedMusicPlayer;

   public MediaAdapter(String audioType){
      if(audioType.equalsIgnoreCase("vlc")){
         advancedMusicPlayer = new VlcPlayer();
      } else if (audioType.equalsIgnoreCase("mp4")){
         advancedMusicPlayer = new Mp4Player();
      }
      if (advancedMusicPlayer == null) {
          System.out.println("MediaAdapter: Invalid media type " + audioType + " for advanced player.");
      }
   }

   @Override
   public void play(String audioType, String fileName) {
      if(advancedMusicPlayer == null) {
          System.out.println("MediaAdapter: Cannot play " + audioType + ". Advanced player not initialized.");
          return;
      }
      if(audioType.equalsIgnoreCase("vlc")){
         advancedMusicPlayer.playVlc(fileName);
      } else if(audioType.equalsIgnoreCase("mp4")){
         advancedMusicPlayer.playMp4(fileName);
      }
   }
}

客户端使用的播放器 (AudioPlayer)

// audio_player.go
package media

import "fmt"

// AudioPlayer 客户端使用的播放器，实现了 MediaPlayer 接口
type AudioPlayer struct {
	mediaAdapter *MediaAdapter // 可以为nil，如果只播放mp3
}

func NewAudioPlayer() *AudioPlayer {
	return &AudioPlayer{}
}

func (ap *AudioPlayer) Play(audioType string, fileName string) {
	// 内置支持播放 mp3 文件
	if audioType == "mp3" {
		fmt.Println("Playing mp3 file. Name:", fileName)
	} else if audioType == "mp4" || audioType == "vlc" {
		// mediaAdapter 提供了对其他文件格式的支持
		ap.mediaAdapter = NewMediaAdapter(audioType)
		if ap.mediaAdapter.advancedPlayer != nil { // 检查适配器是否成功初始化
            ap.mediaAdapter.Play(audioType, fileName)
        } else {
            fmt.Printf("Invalid media type %s format not supported\n", audioType)
        }
	} else {
		fmt.Printf("Invalid media type %s format not supported\n", audioType)
	}
}

// AudioPlayer.java
package com.example.media;

// 客户端使用的播放器，实现了 MediaPlayer 接口
public class AudioPlayer implements MediaPlayer {
   MediaAdapter mediaAdapter;

   @Override
   public void play(String audioType, String fileName) {
      // 内置支持播放 mp3 文件
      if(audioType.equalsIgnoreCase("mp3")){
         System.out.println("Playing mp3 file. Name: "+ fileName);
      }
      // mediaAdapter 提供了对其他文件格式的支持
      else if(audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")){
         mediaAdapter = new MediaAdapter(audioType);
         if (mediaAdapter.advancedMusicPlayer != null) { // 确保适配器已为该类型初始化
            mediaAdapter.play(audioType, fileName);
         } else {
             System.out.println("Invalid media. " + audioType + " format not supported by adapter");
         }
      }
      else{
         System.out.println("Invalid media. " + audioType + " format not supported");
      }
   }
}

客户端使用

// main.go (示例用法)
/*
package main

import "./media"

func main() {
	audioPlayer := media.NewAudioPlayer()

	audioPlayer.Play("mp3", "beyond the horizon.mp3")
	audioPlayer.Play("mp4", "alone.mp4")
	audioPlayer.Play("vlc", "far far away.vlc")
	audioPlayer.Play("avi", "mind me.avi")
}
*/

// Main.java (示例用法)
/*
package com.example;

import com.example.media.AudioPlayer;

public class Main {
   public static void main(String[] args) {
      AudioPlayer audioPlayer = new AudioPlayer();

      audioPlayer.play("mp3", "beyond the horizon.mp3");
      audioPlayer.play("mp4", "alone.mp4");
      audioPlayer.play("vlc", "far far away.vlc");
      audioPlayer.play("avi", "mind me.avi");
   }
}
*/

7. 与其他模式的比较

• 适配器模式 vs. 桥接模式 (Bridge Pattern)：

  • 目的不同：适配器主要解决两个已有接口不兼容的问题（通常是事后补救）；桥接模式主要目的是将抽象部分与实现部分分离，使它们可以独立变化（通常是预先设计）。
  • 时机不同：适配器通常在系统完成后，需要集成新组件或兼容旧组件时使用；桥接模式在系统设计初期就考虑分离变化。

• 适配器模式 vs. 装饰器模式 (Decorator Pattern)：

  • 目的不同：适配器是转换接口；装饰器是动态地给对象添加额外的职责（增强功能），而不改变其接口。
  • 结果不同：适配器返回的是一个符合目标接口的新对象（或包装对象）；装饰器返回的是一个与原对象接口一致，但功能增强的对象。

• 适配器模式 vs. 外观模式 (Facade Pattern)：

  • 目的不同：适配器是转换接口；外观模式是为复杂的子系统提供一个简化的统一接口。
  • 处理对象数量不同：适配器通常适配一个对象；外观模式通常封装多个子系统对象。

8. 总结

适配器模式是一种非常有用的结构型模式，它像一个“万能插头”或“翻译官”，能够解决因接口不兼容而导致类无法协同工作的问题。通过引入适配器，我们可以复用现有的类，并使系统更加灵活。在实际开发中，对象适配器因其更高的灵活性而更被推荐使用。

记住它的核心：转换接口，兼容现有。