深入理解设计模式之适配器模式

已于 2025-05-24 22:21:31 修改
阅读量901 收藏 18
点赞数 23
分类专栏： 设计模式系列 文章标签： 设计模式 适配器模式
于 2025-05-24 22:00:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljw714/article/details/148196869
版权

深入理解设计模式之适配器模式

1. 适配器模式概述

适配器模式(Adapter Pattern)是一种结构型设计模式，它允许将一个类的接口转换为客户端所期望的另一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的类能够协同工作，扮演了"转换器"的角色。

2. 适配器模式的核心组成

  • 目标接口(Target): 客户端所期望的接口
  • 适配者(Adaptee): 需要被适配的类或接口
  • 适配器(Adapter): 将适配者接口转换为目标接口的类

3. 适配器模式的类型

3.1 对象适配器

通过组合方式实现，适配器持有适配者的实例。

3.2 类适配器

通过继承方式实现，适配器同时继承适配者和实现目标接口。

4. 适配器模式实现

4.1 对象适配器实现

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

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

// 具体适配者实现
class VlcPlayer implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        System.out.println("Playing vlc file: " + fileName);
    }

    @Override
    public void playMp4(String fileName) {
        // 不做任何事
    }
}

class Mp4Player implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        // 不做任何事
    }

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

// 适配器
class MediaAdapter implements MediaPlayer {
    private AdvancedMediaPlayer advancedMusicPlayer;

    public MediaAdapter(String audioType) {
        if (audioType.equalsIgnoreCase("vlc")) {
            advancedMusicPlayer = new VlcPlayer();
        } else if (audioType.equalsIgnoreCase("mp4")) {
            advancedMusicPlayer = new Mp4Player();
        }
    }

    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("vlc")) {
            advancedMusicPlayer.playVlc(fileName);
        } else if (audioType.equalsIgnoreCase("mp4")) {
            advancedMusicPlayer.playMp4(fileName);
        }
    }
}

// 客户端
class AudioPlayer implements MediaPlayer {
    private MediaAdapter mediaAdapter;

    @Override
    public void play(String audioType, String fileName) {
        // 播放mp3格式音频文件的内置支持
        if (audioType.equalsIgnoreCase("mp3")) {
            System.out.println("Playing mp3 file: " + fileName);
        }
        // 通过适配器播放其他格式
        else if (audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")) {
            mediaAdapter = new MediaAdapter(audioType);
            mediaAdapter.play(audioType, fileName);
        } else {
            System.out.println("Invalid media. " + audioType + " format not supported");
        }
    }
}

// 测试类
public class AdapterPatternDemo {
    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");
    }
}

4.2 类适配器实现

// 目标接口
interface Target {
    void request();
}

// 适配者类
class Adaptee {
    public void specificRequest() {
        System.out.println("Specific request from Adaptee");
    }
}

// 类适配器
class ClassAdapter extends Adaptee implements Target {
    @Override
    public void request() {
        specificRequest(); // 调用父类方法
    }
}

// 测试类
public class ClassAdapterDemo {
    public static void main(String[] args) {
        Target target = new ClassAdapter();
        target.request();
    }
}

5. 真实世界适配器模式示例

5.1 旧系统集成案例

// 旧支付系统接口
class LegacyPaymentSystem {
    public void processPayment(String amount, String account) {
        System.out.println("Legacy payment processed: " + amount + " from account: " + account);
    }
}

// 新支付接口
interface ModernPaymentGateway {
    void processPayment(Payment payment);
}

// 支付数据传输对象
class Payment {
    private double amount;
    private String accountId;
    private String currency;
    
    public Payment(double amount, String accountId, String currency) {
        this.amount = amount;
        this.accountId = accountId;
        this.currency = currency;
    }
    
    public double getAmount() {
        return amount;
    }
    
    public String getAccountId() {
        return accountId;
    }
    
    public String getCurrency() {
        return currency;
    }
}

// 支付系统适配器
class PaymentSystemAdapter implements ModernPaymentGateway {
    private LegacyPaymentSystem legacySystem;
    
    public PaymentSystemAdapter() {
        this.legacySystem = new LegacyPaymentSystem();
    }
    
    @Override
    public void processPayment(Payment payment) {
        // 转换和适配
        String amount = payment.getAmount() + " " + payment.getCurrency();
        legacySystem.processPayment(amount, payment.getAccountId());
    }
}

// 客户端代码
public class PaymentSystemDemo {
    public static void main(String[] args) {
        // 创建新的支付请求
        Payment payment = new Payment(100.50, "ACC123456", "USD");
        
        // 使用适配器处理支付
        ModernPaymentGateway paymentGateway = new PaymentSystemAdapter();
        paymentGateway.processPayment(payment);
    }
}

5.2 第三方库集成案例

// 第三方图表库接口
class ThirdPartyChartLibrary {
    public void displayChart(String data, String type, int width, int height) {
        System.out.println("Displaying " + type + " chart with data: " + data);
        System.out.println("Dimensions: " + width + "x" + height);
    }
}

// 应用程序预期的图表接口
interface AppChartInterface {
    void drawChart(ChartData data);
}

// 图表数据
class ChartData {
    private String dataPoints;
    private ChartType type;
    private Dimension size;
    
    public ChartData(String dataPoints, ChartType type, Dimension size) {
        this.dataPoints = dataPoints;
        this.type = type;
        this.size = size;
    }
    
    public String getDataPoints() {
        return dataPoints;
    }
    
    public ChartType getType() {
        return type;
    }
    
    public Dimension getSize() {
        return size;
    }
}

// 图表类型枚举
enum ChartType {
    BAR, LINE, PIE
}

// 尺寸类
class Dimension {
    private int width;
    private int height;
    
    public Dimension(int width, int height) {
        this.width = width;
        this.height = height;
    }
    
    public int getWidth() {
        return width;
    }
    
    public int getHeight() {
        return height;
    }
}

// 图表库适配器
class ChartLibraryAdapter implements AppChartInterface {
    private ThirdPartyChartLibrary chartLibrary;
    
    public ChartLibraryAdapter() {
        this.chartLibrary = new ThirdPartyChartLibrary();
    }
    
    @Override
    public void drawChart(ChartData data) {
        // 转换数据格式
        String chartType = data.getType().toString().toLowerCase();
        chartLibrary.displayChart(
            data.getDataPoints(),
            chartType,
            data.getSize().getWidth(),
            data.getSize().getHeight()
        );
    }
}

// 客户端代码
public class ChartAdapterDemo {
    public static void main(String[] args) {
        // 创建图表数据
        ChartData barChartData = new ChartData(
            "10,25,30,40,50",
            ChartType.BAR,
            new Dimension(800, 400)
        );
        
        // 使用适配器绘制图表
        AppChartInterface chartInterface = new ChartLibraryAdapter();
        chartInterface.drawChart(barChartData);
    }
}

6. 双向适配器模式

// 接口A
interface SystemA {
    void operationA();
}

// 接口B
interface SystemB {
    void operationB();
}

// 系统A实现
class ConcreteSystemA implements SystemA {
    @Override
    public void operationA() {
        System.out.println("System A: performing operation A");
    }
}

// 系统B实现
class ConcreteSystemB implements SystemB {
    @Override
    public void operationB() {
        System.out.println("System B: performing operation B");
    }
}

// 双向适配器
class TwoWayAdapter implements SystemA, SystemB {
    private SystemA systemA;
    private SystemB systemB;
    
    public TwoWayAdapter(SystemA systemA, SystemB systemB) {
        this.systemA = systemA;
        this.systemB = systemB;
    }
    
    @Override
    public void operationA() {
        System.out.println("Adapter: redirecting operationA to operationB");
        systemB.operationB();
    }
    
    @Override
    public void operationB() {
        System.out.println("Adapter: redirecting operationB to operationA");
        systemA.operationA();
    }
}

// 测试双向适配器
public class TwoWayAdapterDemo {
    public static void main(String[] args) {
        SystemA systemA = new ConcreteSystemA();
        SystemB systemB = new ConcreteSystemB();
        
        // 创建双向适配器
        TwoWayAdapter adapter = new TwoWayAdapter(systemA, systemB);
        
        // 通过适配器调用SystemA的功能
        System.out.println("Client uses SystemA interface:");
        adapter.operationA();
        
        // 通过适配器调用SystemB的功能
        System.out.println("\nClient uses SystemB interface:");
        adapter.operationB();
    }
}

7. Java标准库中的适配器模式

Java标准库中有多处使用了适配器模式：

import java.io.*;
import java.util.*;

public class JavaAdapterExamples {
    public static void main(String[] args) {
        // 示例1: InputStreamReader作为适配器
        // InputStream(适配者) -> Reader(目标接口)
        try {
            InputStream is = new FileInputStream("file.txt");
            Reader reader = new InputStreamReader(is, "UTF-8");
            
            int data = reader.read();
            while(data != -1) {
                System.out.print((char) data);
                data = reader.read();
            }
            
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        // 示例2: Arrays.asList()作为适配器
        // 数组(适配者) -> List(目标接口)
        String[] namesArray = {"John", "Jane", "Adam"};
        List<String> namesList = Arrays.asList(namesArray);
        
        // 使用List接口的方法
        System.out.println(namesList.get(1));
        System.out.println(namesList.contains("Jane"));
        
        // 示例3: Collections.enumeration()作为适配器
        // Collection(适配者) -> Enumeration(目标接口)
        List<String> list = new ArrayList<>();
        list.add("Item 1");
        list.add("Item 2");
        
        Enumeration<String> enumeration = Collections.enumeration(list);
        while(enumeration.hasMoreElements()) {
            System.out.println(enumeration.nextElement());
        }
    }
}

8. 适配器模式的优缺点

优点

  • 解耦合: 客户端与被适配者解耦，通过目标接口进行交互
  • 复用性: 可以复用现有的类，即使接口不匹配
  • 灵活性: 可以在不修改原有代码的情况下使用已有功能
  • 开闭原则: 符合"开闭原则"，不修改原有代码而扩展功能

缺点

  • 复杂性: 引入额外的类，增加系统复杂度
  • 性能开销: 可能引入额外的间接调用，影响性能
  • 可读性: 过多的适配器会使系统难以理解

9. 适配器模式的适用场景

  • 集成遗留系统: 当需要集成旧系统或第三方库时
  • 接口不兼容: 当现有接口与客户端期望的接口不兼容时
  • 类库迁移: 当迁移到新的类库但不想修改现有代码时
  • 多态接口: 当需要统一多个类的接口时

10. 适配器模式与其他模式的比较

模式适配器模式桥接模式装饰器模式代理模式
意图使不兼容接口兼容将抽象与实现分离动态添加功能控制对象访问
结构转换接口分离层次结构包装对象包装对象
侧重点接口转换接口与实现分离功能扩展访问控制

11. 总结

适配器模式是一种强大的结构型设计模式，用于解决接口不兼容问题。它在系统集成、类库迁移和接口统一等场景中非常有用。通过将一个类的接口转换为客户端期望的另一个接口，适配器让原本不兼容的类能够协同工作。

适配器模式的两种主要实现方式——对象适配器和类适配器，为不同场景提供了灵活的解决方案。在实际开发中，对象适配器因其更高的灵活性和更低的耦合度而被更广泛使用。

适当使用适配器模式可以大大提高代码的可维护性和可扩展性，特别是在处理遗留系统和第三方库集成时。但也应注意避免过度使用适配器，以免增加系统的复杂性。

【设计模式】6.深入理解 Java 中的适配器模式
m0_38053034的博客
10-18 71
/ 客户期望的接口// 需要被适配的类，它的接口与 Target 不兼容适配器模式是一种常见的结构型设计模式，它的主要作用是将一个接口转换为客户期望的另一个接口，使得原本接口不兼容的类能够协同工作。通过适配器模式，我们可以提高系统的灵活性和复用性，同时遵循开闭原则，降低修改已有代码的风险。适配器模式分为类适配器和对象适配器，两者各有优缺点。类适配器通过继承实现，较为直接但灵活性不足；对象适配器通过组合实现，虽然需要更多的代码，但灵活性更强。在实际开发中，我们通常优先考虑对象适配器模式。
【深入理解设计模式】适配器设计模式
guojiaqi_的博客
02-25 1457
适配器设计模式是一种结构型设计模式，用于将一个类的接口转换成客户端所期望的另一个接口，从而使得原本由于接口不兼容而不能一起工作的类能够一起工作。
深入理解设计模式-适配器模式
少说，多做
04-24 5943
将一个类的接口，转换成客户期望的另一个接口。适配器让原来接口不谦容的类可以合作无间。Target（目标抽象类）： 目标抽象类定义客户所需接口，可以是一个抽象类或接口，也可以是具体类Adaptee（适配者类）： 适配者即被适配的角色，它定义了一个已经存在的接口，这个接口需要适配，适配者类一般是一个具体类，包含了客户希望使用的业务方法，在某些情况下可能没有适配者类的源代码。
设计模式之适配器模式：原理、实现与应用
wenbin_java的博客
03-12 1922
适配器模式是一种结构型设计模式，它通过将一个类的接口转换成客户端所期望的另一个接口，使得原本不兼容的类可以协同工作。适配器模式通常用于系统集成、接口兼容等场景。适配器模式是设计模式中用于接口兼容和系统集成的经典模式之一，适用于需要将不兼容的接口转换为兼容接口的场景。通过掌握适配器模式的原理、实现方式以及最佳实践，你可以在实际开发中更好地应用这一模式。希望本文能为你的设计模式学习之旅提供一些实用的指导！如果你有具体的需求或想要深入探讨某个主题，请告诉我，我可以进一步调整内容！
深入理解Java设计模式——适配器模式
记录各种Bug解决案例及日常学习内容
04-20 970
目录一、什么是适配器模式二、适配器模式角色划分三、适配器模式应用场景四、适配器创建的方式五、适配器快速入门例子六、使用适配器模式实现日志收集1. 对象适配器方式实现1.1 定义基本实体类2. 适配器模式优缺点七、Mybatis 日志收集分析1. slf4j源码分析 一、什么是适配器模式 将一个系统的接口转换成另外一种形式，从而使原来不能直接调用的接口变得可以调用。 二、适配器模式角色划分 适配器模式涉及3个角色： 源（Adaptee）：需要被适配的对象或类型， 旧版本或者苹果手机插口 适配器（Adapt
深入设计模式-适配器模式「GO 版本」
pengyachuan的博客
02-14 820
为什么会写“适配器”模式呢？主要有 2 个原因：1、使用“适配器”模式的场景比较多，比如“监听”系统内部事件适配数据、调用三方接口适配接口数据等。2、写“适配器”模式文章少或者说能写的深的文章少并且没有结合具体的业务场景。后文会举真实案例，“适配器”模式如何解决项目上的痛点。
重读Java设计模式: 适配器模式解析
MarkusZhang的博客
04-05 2654
在软件开发中，经常会遇到不同接口之间的兼容性问题。当需要使用一个已有的类，但其接口与我们所需的不兼容时，我们可以通过适配器模式来解决这一问题。适配器模式是一种结构型设计模式，它允许接口不兼容的类之间进行合作。本文将深入探讨适配器模式的概念、应用场景以及在Java中的实现方式。
软件设计模式：适配器模式详解
nbsaas-boot基于Request-Response的企业级快速开发框架
02-24 951
适配器模式是一种结构型设计模式，旨在让不兼容的接口能够一起工作。它通过引入一个适配器来转换一个类的接口成客户端期望的另一个接口，从而实现系统组件的协同工作。适用场景。
深入理解 C# 中的适配器模式：连接不兼容的世界
hy_4377的博客
08-30 1467
适配器模式是一个非常实用的设计模式，尤其在面对不兼容接口的整合时。通过适配器模式，开发者可以在不修改现有代码的情况下，使得不同的接口能够协同工作，从而提升系统的扩展性和维护性。在本文中，我们通过一个 C# 的实际示例展示了如何使用适配器模式来整合不同的支付系统。理解和应用适配器模式，可以帮助我们在软件开发中更好地应对接口不兼容的问题。
深入理解JavaScript系列（39）：设计模式之适配器模式详解
10-24
主要介绍了深入理解JavaScript系列（39）：设计模式之适配器模式详解,适配器模式（Adapter）是将一个类（对象）的接口（方法或属性）转化成客户希望的另外一个接口（方法或属性）,需要的朋友可以参考下
设计模式之适配器模式
01-28
通过阅读博客中的实例代码，我们可以更深入地理解适配器模式的工作原理和具体实现方式，这对于提升软件设计能力非常有帮助。适配器模式不仅可以提高代码的复用性，还能使系统更加灵活，减少因接口不兼容导致的修改...
java设计模式之适配器模式.zip
09-06
继续理解和思考适配器模式.avi"这些视频资源，你将进一步深入理解适配器模式的概念、工作原理以及如何在实际项目中灵活运用。适配器模式是Java开发者必备的设计模式之一，掌握它能帮助你更好地构建可扩展和可维护的...
Spring声明式事务源码全链路剖析与设计模式深度解读
weixin_39863120的博客
05-22 1076
Spring事务是企业级开发的基石，但“为什么有时事务失效？”、“不同传播行为背后发生了什么？”、“Spring事务源码到底如何实现？”这些问题困扰着无数开发者。本文将从源码行级剖析事务传播机制全链路跟踪设计模式变体实现三个层面，彻底解构Spring声明式事务体系。Spring事务的本质，是AOP+多设计模式联合作用的工程艺术。理解每一行源码，追踪每一个传播行为的全链路，能让你真正掌控事务边界与一致性。知其然，更知其所以然。
单例模式的运用
m0_62458145的博客
05-22 630
在这个类中，我们通过单例模式确保了整个应用只维护一个 Milvus 客户端连接，避免了资源浪费和连接泄漏的风险。在我们的向量数据库配置类 MilvusVectorDatabaseConfig 中，采用了单例模式的实现方式，这是一种非常经典且实用的设计模式。在今后的开发中，我将更加注重设计模式的合理应用，特别是在处理共享资源和全局唯一对象时，单例模式将是我的首选方案之一。对于资源密集型的单例对象，需要考虑资源的生命周期管理。单例模式虽然简单，但在实际应用中需要考虑很多细节问题。无需考虑延迟加载问题。
Java集合框架深度剖析：结构、并发与设计模式全解析
2301_79902294的博客
05-22 1323
Java 集合框架是用于存储和操作对象数据的统一 API，主要分为 Collection 和 Map 两大体系。Collection 包括 List（有序可重复）、Set（无序不可重复）和 Queue（队列操作），而 Map 用于存储键值对。常见实现类如 ArrayList、HashSet、HashMap 等。
25年上半年五月之软考之设计模式
m0_75153577的博客
05-23 912
可能有人会疑问，为什么要写接口，为什么要写不同的奶茶类，试想，如果我们把所有实现奶茶的方法放在一个类里，让客户去从一个类里调用，判断条件会变多，代码也会变得很长，我们在寻找这些条件的时候，运行速度可能会变慢。这个模式很好理解，面对同一个类有不同的策略，假如你想买车，不考虑预算，你想买什么车就买什么车，可以买白色宝马，灰色宝马，黑色宝马，黑色奔驰，灰色奔驰，白色小米，黄色小米，等等。代码实现：一个真实的类，一个代理真实的类，一个抽象的接口，代理与真实的类拥有相同的功能。首先，先来梳理一下代码思路。
设计模式1 ——单例模式
b405516801的博客
05-21 525
在 C++ 里，单例模式是一种常用的设计模式，其目的是保证一个类仅存在一个实例，并且为该实例提供一个全局访问点。
Python类的力量：第六篇：设计模式——Python面向对象编程的“架构蓝图”
dudly的博客
05-20 1649
在软件开发中，设计模式（Design Patterns）是经过反复验证的通用解决方案，能够有效解决特定场景下的设计问题。通过应用设计模式，开发者可以将复杂的业务逻辑转化为可复用的架构模块，提升代码的可维护性、扩展性和健壮性。本文将结合Python的动态特性，解析**单例模式**、**工厂模式**、**观察者模式**等经典设计模式的实现原理与行业应用，帮助读者构建“可复用、易扩展”的代码体系。
Java设计模式: 工厂模式与策略模式
最新发布
caihuayuan4的博客
05-23 947
工厂模式将对象的创建过程封装在工厂方法中，使得客户端无需关心对象的实际创建过程，只需通过工厂方法获取所需的对象。工厂模式和策略模式是常用的设计模式之一，它们能够帮助开发人员更好地组织和管理代码，提高代码的可维护性和可扩展性。在上面的示例中，建立了一个简单工厂`SimpleFactory`类，通过传入不同的产品类型参数，创建不同的产品对象。本文详细介绍了工厂模式和策略模式的概念、原理和实际应用，并结合代码示例进行详细讲解，旨在帮助开发人员更好地组织和管理代码，提高代码的可维护性和可扩展性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值