【适配器模式】设计模式: 穿越接口的时空隧道(架起接口间的桥梁)

于 2024-08-08 07:30:00 发布
阅读量451 收藏 8
点赞数 11
分类专栏： # 设计模式 文章标签： 适配器模式 设计模式 结构型设计模式 后端 java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68020300/article/details/141000374
版权

文章目录

Java 设计模式之适配器模式：理论与实践

1. 引言

1.1 结构型模式介绍

  • 定义：结构型设计模式关注如何组合类或对象来形成更大的结构，以便它们可以协同工作。
  • 目的：简化复杂度，使得系统的设计更加灵活，易于维护和扩展。
  • 常见模式：简要介绍几种常见的结构型模式，如适配器模式、桥接模式、装饰器模式等。

1.2 为什么需要适配器模式？

  • 接口不兼容的问题：在软件系统中，经常遇到不同组件之间接口不匹配的情况。
  • 重用现有类：适配器模式允许我们重用现有的类，而无需修改它们的源代码。
  • 灵活性和扩展性：通过引入适配器，我们可以更容易地添加新的类或接口，提高系统的灵活性。

2. 适配器模式概述

2.1 定义

  • 定义：适配器模式是一种结构型设计模式，它允许不兼容的接口之间的类可以一起工作。
  • 关键特点：通过创建一个新的适配器类来包装原有的类或接口，从而实现接口的转换。

2.2 关键概念

  • Target (目标)：定义了客户端期望的接口。
  • Adaptee (被适配者)：定义了已经存在的接口，但其接口不符合目标接口的要求。
  • Adapter (适配器)：适配器类实现了目标接口，并调用被适配者的功能。

2.3 适配器模式的类型

类适配器模式

  • 定义：适配器继承自被适配者，并实现目标接口。
  • 实现：通过继承的方式实现接口的适配。
  • 示例：简单示例说明类适配器模式的使用。

对象适配器模式

  • 定义：适配器通过关联关系（通常通过组合）来持有被适配者的实例，并实现目标接口。
  • 实现：通过组合的方式实现接口的适配。
  • 示例：简单示例说明对象适配器模式的使用。

接口适配器模式

  • 定义：当类需要实现一个接口，但不需要使用该接口的所有方法时，可以通过定义一个默认实现的适配器类来简化实现过程。
  • 实现：通过定义一个默认实现的适配器类，子类可以选择性地覆盖其中的方法。
  • 示例：简单示例说明接口适配器模式的使用。

3. 适配器模式的参与者

Target（目标）

  • 定义：目标接口或抽象类定义了客户端期望的接口。
  • 作用：提供了一个一致的接口供客户端调用。
  • 示例：假设我们有一个 MediaPlayer 接口，它定义了一个 play(String audioType, String fileName) 方法。

Adaptee（被适配者）

  • 定义：被适配者是指那些已经存在的类或接口，但其接口不符合目标接口的要求。
  • 作用：提供了一些有用的功能，但这些功能的接口与目标接口不兼容。
  • 示例：假设我们有两个类 AdvancedAudioPlayer 和 Mp4Player，它们分别能够播放 Vlc 和 Mp4 格式的音频文件。

Adapter（适配器）

  • 定义：适配器类实现了目标接口，并调用了被适配者的功能。
  • 作用：作为中间件，将被适配者的接口转换为目标接口。
  • 示例：创建一个 MediaAdapter 类，它可以将 AdvancedAudioPlayer 和 Mp4Player 的功能封装起来，以适应 MediaPlayer 接口。

Client（客户端）

  • 定义：客户端是使用目标接口的代码。
  • 作用：客户端代码只需要知道目标接口，而不必了解适配器或被适配者的具体实现。
  • 示例：客户端代码可以通过调用 MediaPlayer 的 play 方法来播放不同格式的音频文件，而无需关心具体的播放逻辑。

对象适配器：
在这里插入图片描述
类适配器：
在这里插入图片描述
时序图：
在这里插入图片描述

4. 适配器模式的工作原理

4.1 类适配器模式的工作流程

  1. 定义目标接口：定义一个客户端期望使用的接口，例如 MediaPlayer。
  2. 定义被适配者：定义一个或多个被适配者类，如 AdvancedAudioPlayer 和 Mp4Player。
  3. 创建适配器类：创建一个适配器类，它继承自被适配者，并实现目标接口。
  4. 实现目标接口的方法：在适配器类中实现目标接口的方法，并调用被适配者相应的方法。
  5. 客户端使用：客户端通过目标接口来使用适配器。

示例代码:

public interface MediaPlayer {
    void play(String audioType, String fileName);
}

public class AdvancedAudioPlayer implements MediaPlayer {
    public void play(String audioType, String fileName) {
        if ("vlc".equalsIgnoreCase(audioType)) {
            System.out.println("Playing vlc file. Name: " + fileName);
        } else if ("mp4".equalsIgnoreCase(audioType)) {
            System.out.println("Playing mp4 file. Name: " + fileName);
        }
    }
}

public class MediaAdapter implements MediaPlayer {
    private AdvancedAudioPlayer advancedAudioPlayer;

    public MediaAdapter() {
        this.advancedAudioPlayer = new AdvancedAudioPlayer();
    }

    @Override
    public void play(String audioType, String fileName) {
        if ("vlc".equalsIgnoreCase(audioType) || "mp4".equalsIgnoreCase(audioType)) {
            advancedAudioPlayer.play(audioType, fileName);
        }
    }
}

4.2 对象适配器模式的工作流程

  1. 定义目标接口：定义一个客户端期望使用的接口，例如 MediaPlayer。
  2. 定义被适配者：定义一个或多个被适配者类，如 AdvancedAudioPlayer 和 Mp4Player。
  3. 创建适配器类：创建一个适配器类，它持有被适配者的引用，并实现目标接口。
  4. 实现目标接口的方法：在适配器类中实现目标接口的方法，并调用被适配者相应的方法。
  5. 客户端使用：客户端通过目标接口来使用适配器。

示例代码:

public class MediaAdapter implements MediaPlayer {
    private AdvancedAudioPlayer advancedAudioPlayer;
    private Mp4Player mp4Player;

    public MediaAdapter() {
        this.advancedAudioPlayer = new AdvancedAudioPlayer();
        this.mp4Player = new Mp4Player();
    }

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

4.3 接口适配器模式的工作流程

  1. 定义目标接口：定义一个客户端期望使用的接口，例如 MediaPlayer。
  2. 定义被适配者：定义一个或多个被适配者类，如 AdvancedAudioPlayer 和 Mp4Player。
  3. 创建适配器类：创建一个适配器类，它实现了目标接口并提供了默认实现。
  4. 实现特定方法：在适配器类中选择性地覆盖某些方法，以提供特定的行为。
  5. 客户端使用：客户端通过目标接口来使用适配器。

示例代码:

public abstract class MediaAdapter implements MediaPlayer {
    protected AdvancedAudioPlayer advancedAudioPlayer;
    protected Mp4Player mp4Player;

    public MediaAdapter() {
        this.advancedAudioPlayer = new AdvancedAudioPlayer();
        this.mp4Player = new Mp4Player();
    }

    @Override
    public void play(String audioType, String fileName) {
        // 默认实现
    }

    public void playVlc(String fileName) {
        advancedAudioPlayer.playVlc(fileName);
    }

    public void playMp4(String fileName) {
        mp4Player.playMp4(fileName);
    }
}

5. 适配器模式的优缺点

5.1 优点

  • 重用性：允许你重用已有的类，而不需要修改它们的源代码。
  • 灵活性：提高了系统的灵活性，可以更容易地扩展或替换系统中的组件。
  • 单一职责原则：通过适配器模式，每个类只需要关注自己的职责，这符合单一职责原则。
  • 易于维护：通过分离接口实现和适配逻辑，使得维护和扩展变得更加容易。
  • 符合开闭原则：可以在不修改现有代码的情况下添加新的适配器，以支持更多的接口。

5.2 缺点

  • 增加系统复杂度：引入额外的适配器类可能会使系统变得更加复杂，尤其是在需要处理多种不同的适配情况时。
  • 性能开销：通过适配器进行间接调用可能比直接调用原始类的方法稍微慢一些。
  • 潜在的错误：如果适配器实现不当，可能会引入新的错误或异常情况。
  • 过度使用：过度使用适配器可能会导致代码难以理解和维护。

6. Java 中的适配器模式实现

6.1 类适配器模式示例

  • 定义目标接口：
public interface MediaPlayer {
   void play(String audioType, String fileName);
}
  • 定义被适配者：
public class AdvancedAudioPlayer implements MediaPlayer {
    public void playVlc(String fileName) {
        System.out.println("Playing vlc file. Name: " + fileName);
    }

    public void playMp4(String fileName) {
        System.out.println("Playing mp4 file. Name: " + fileName);
    }
}
  • 创建适配器类：
public class MediaAdapter extends AdvancedAudioPlayer implements MediaPlayer {
    @Override
    public void play(String audioType, String fileName) {
        if ("vlc".equalsIgnoreCase(audioType)) {
            playVlc(fileName);
        } else if ("mp4".equalsIgnoreCase(audioType)) {
            playMp4(fileName);
        }
    }
}
  • 客户端使用：
public class AudioPlayerTestDrive {
    public static void main(String[] args) {
        MediaPlayer advancedMusicPlayer = new MediaAdapter();
        advancedMusicPlayer.play("vlc", "song.vlc");
        advancedMusicPlayer.play("mp4", "song.mp4");
    }
}

6.2 对象适配器模式示例

  • 定义目标接口：
public interface MediaPlayer {
    void play(String audioType, String fileName);
}
  • 定义被适配者：
public class AdvancedAudioPlayer {
    public void playVlc(String fileName) {
        System.out.println("Playing vlc file. Name: " + fileName);
    }

    public void playMp4(String fileName) {
        System.out.println("Playing mp4 file. Name: " + fileName);
    }
}
  • 创建适配器类：
public class MediaAdapter implements MediaPlayer {
    private AdvancedAudioPlayer advancedAudioPlayer;

    public MediaAdapter(AdvancedAudioPlayer advancedAudioPlayer) {
        this.advancedAudioPlayer = advancedAudioPlayer;
    }

    @Override
    public void play(String audioType, String fileName) {
        if ("vlc".equalsIgnoreCase(audioType)) {
            advancedAudioPlayer.playVlc(fileName);
        } else if ("mp4".equalsIgnoreCase(audioType)) {
            advancedAudioPlayer.playMp4(fileName);
        }
    }
}
  • 客户端使用：
public class AudioPlayerTestDrive {
    public static void main(String[] args) {
        AdvancedAudioPlayer advancedAudioPlayer = new AdvancedAudioPlayer();
        MediaPlayer mediaAdapter = new MediaAdapter(advancedAudioPlayer);
        mediaAdapter.play("vlc", "song.vlc");
        mediaAdapter.play("mp4", "song.mp4");
    }
}

6.3 接口适配器模式示例

6.3.1 实现代码
  • 定义目标接口：
public interface MediaPlayer {
    void play(String audioType, String fileName);
}
  • 定义被适配者：
public class AdvancedAudioPlayer {
    public void playVlc(String fileName) {
        System.out.println("Playing vlc file. Name: " + fileName);
    }

    public void playMp4(String fileName) {
        System.out.println("Playing mp4 file. Name: " + fileName);
    }
}
  • 创建适配器类：
public class MediaAdapter implements MediaPlayer {
    private AdvancedAudioPlayer advancedAudioPlayer;

    public MediaAdapter(AdvancedAudioPlayer advancedAudioPlayer) {
        this.advancedAudioPlayer = advancedAudioPlayer;
    }

    @Override
    public void play(String audioType, String fileName) {
        if ("vlc".equalsIgnoreCase(audioType)) {
            advancedAudioPlayer.playVlc(fileName);
        } else if ("mp4".equalsIgnoreCase(audioType)) {
            advancedAudioPlayer.playMp4(fileName);
        }
    }
}
6.3.2 运行示例
  • 客户端使用：
public class AudioPlayerTestDrive {
    public static void main(String[] args) {
        AdvancedAudioPlayer advancedAudioPlayer = new AdvancedAudioPlayer();
        MediaPlayer mediaAdapter = new MediaAdapter(advancedAudioPlayer);
        mediaAdapter.play("vlc", "song.vlc");
        mediaAdapter.play("mp4", "song.mp4");
    }
}

7. 应用场景

7.1 现实世界案例

  • 电源适配器：当你在国外旅行时，你的电子设备可能需要一个电压适配器来匹配当地的电源插座。这种适配器将电源插头从一种标准转换为另一种标准，就像适配器模式在软件中所做的那样。
  • 耳机转接器：许多现代智能手机取消了3.5毫米耳机插孔，因此你需要一个适配器来将标准耳机连接到USB-C接口上。这个适配器充当了一个转换器，使得耳机能够正常工作。

7.2 软件开发案例

7.2.1 案例一：数据库驱动适配
  • 场景描述：假设你正在开发一个应用程序，该程序需要与多种不同类型的数据库进行交互。为了保持代码的灵活性和可扩展性，你可以使用适配器模式来封装不同数据库驱动的特定行为。
  • 实现思路：
    1. 定义目标接口：创建一个通用的数据库访问接口。
    2. 定义被适配者：对于每种数据库（如MySQL、PostgreSQL等），都有一个具体的数据库驱动类。
    3. 创建适配器类：为每种数据库驱动创建一个适配器类，该类实现通用的数据库访问接口，并调用相应的数据库驱动方法。
    4. 客户端使用：客户端通过调用通用的数据库访问接口来执行查询操作，而不需要关心底层数据库的具体实现。

示例代码:

// 目标接口
public interface DatabaseConnection {
    void connect(String connectionString);
    ResultSet query(String sql);
    void close();
}

// 被适配者
public class MySQLDriver {
    public void connect(String connectionString) {
        System.out.println("Connecting to MySQL database at " + connectionString);
    }

    public ResultSet query(String sql) {
        System.out.println("Executing SQL: " + sql);
        return new ResultSet();
    }

    public void close() {
        System.out.println("Closing MySQL connection");
    }
}

// 适配器类
public class MySQLAdapter implements DatabaseConnection {
    private MySQLDriver mysqlDriver;

    public MySQLAdapter(MySQLDriver mysqlDriver) {
        this.mysqlDriver = mysqlDriver;
    }

    @Override
    public void connect(String connectionString) {
        mysqlDriver.connect(connectionString);
    }

    @Override
    public ResultSet query(String sql) {
        return mysqlDriver.query(sql);
    }

    @Override
    public void close() {
        mysqlDriver.close();
    }
}

// 客户端使用
public class DatabaseTestDrive {
    public static void main(String[] args) {
        MySQLDriver mysqlDriver = new MySQLDriver();
        DatabaseConnection dbConnection = new MySQLAdapter(mysqlDriver);
        dbConnection.connect("jdbc:mysql://localhost:3306/testdb");
        dbConnection.query("SELECT * FROM users");
        dbConnection.close();
    }
}
7.2.2 案例二：GUI 组件适配
  • 场景描述：在图形用户界面（GUI）开发中，不同的平台（如Windows、Mac OS等）可能有不同的GUI组件实现。为了保持跨平台的一致性，可以使用适配器模式来封装这些差异。
  • 实现思路：
    1. 定义目标接口：创建一个通用的GUI组件接口。
    2. 定义被适配者：对于每种平台，都有一个具体的GUI组件实现。
    3. 创建适配器类：为每种平台创建一个适配器类，该类实现通用的GUI组件接口，并调用相应的平台组件方法。
    4. 客户端使用：客户端通过调用通用的GUI组件接口来创建和管理GUI组件，而不需要关心底层平台的具体实现。

示例代码:

// 目标接口
public interface Button {
    void click();
    void setLabel(String label);
}

// 被适配者
public class WinButton {
    public void click() {
        System.out.println("WinButton clicked");
    }

    public void setCaption(String caption) {
        System.out.println("WinButton caption set to " + caption);
    }
}

// 适配器类
public class WinButtonAdapter implements Button {
    private WinButton winButton;

    public WinButtonAdapter(WinButton winButton) {
        this.winButton = winButton;
    }

    @Override
    public void click() {
        winButton.click();
    }

    @Override
    public void setLabel(String label) {
        winButton.setCaption(label);
    }
}

// 客户端使用
public class GUIComponentTestDrive {
    public static void main(String[] args) {
        WinButton winButton = new WinButton();
        Button button = new WinButtonAdapter(winButton);
        button.setLabel("Click Me");
        button.click();
    }
}

8. 最佳实践

使用场景选择

  • 接口不兼容：当需要连接两个不兼容的接口时，适配器模式是一个很好的选择。
  • 重用现有代码：如果你想要重用一些现有的类，但它们的接口与你的系统不兼容，适配器模式可以帮助你解决这个问题。
  • 扩展性和灵活性：当系统需要扩展以支持未来的新功能时，适配器模式提供了一种灵活的方式来实现这一点。

避免过度使用适配器

  • 尽量避免不必要的层次：过度使用适配器会导致代码变得复杂且难以维护。
  • 考虑其他模式：有时候其他模式（如桥接模式或装饰者模式）可能是更好的解决方案。

性能考量

  • 性能影响：适配器模式可能会带来一些性能上的开销，因为通过适配器进行间接调用比直接调用原始类的方法稍微慢一些。
  • 缓存机制：如果适配器模式被频繁使用，可以考虑使用缓存机制来减少重复的适配工作。

9. 深入理解

9.1 适配器模式与其他模式的区别

  1. 适配器模式 vs 桥接模式
  • 适配器模式：主要用于解决已有接口与所需接口不兼容的问题，通过适配器将现有类的接口转换为目标接口。
  • 桥接模式：用于解耦一个抽象及其实现，使得抽象和实现可以独立变化。适配器模式通常用于解决单一的接口不兼容问题，而桥接模式则用于解决抽象与实现分离的问题。
  1. 适配器模式 vs 装饰者模式
  • 适配器模式：主要用于接口转换，使得不兼容的接口可以一起工作。
  • 装饰者模式：用于动态地给一个对象添加一些额外的责任，通常用于扩展对象的功能，而不是改变接口。
  1. 适配器模式 vs 代理模式
  • 适配器模式：用于转换接口。
  • 代理模式：为另一个对象提供一个代理以控制对该对象的访问，通常用于添加额外的行为，比如权限检查、日志记录等。

9.2 适配器模式的变体

  • 类适配器模式：适配器继承自被适配者，并实现目标接口。
  • 对象适配器模式：适配器通过组合的方式持有被适配者的实例，并实现目标接口。
  • 接口适配器模式：用于实现一个接口，但不需要使用该接口的所有方法时，可以通过定义一个默认实现的适配器类来简化实现过程。

9.3 适配器模式的扩展

  • 多重适配：适配器可以适配多个不同的接口。
  • 适配器链：多个适配器可以串联起来，形成一个适配器链，以支持更复杂的转换逻辑。
  • 适配器工厂：可以通过一个适配器工厂来创建多个适配器实例，以支持不同场景下的适配需求。

10. 实战案例分析

10.1 案例背景

  • 场景描述：假设你正在开发一个多媒体播放器应用，该应用需要支持多种音频格式，包括MP3、WAV、FLAC等。但是，你发现现有的音频播放库只支持MP3和WAV格式，而不支持FLAC格式。

10.2 需求分析

  • 目标接口：定义一个统一的音频播放接口，让播放器可以播放所有格式的音频文件。
  • 被适配者：已有的音频播放库支持MP3和WAV格式。
  • 适配器需求：创建一个适配器，使得FLAC格式的音频文件也可以通过现有的播放库播放。

10.3 设计方案

  • 定义目标接口：创建一个AudioPlayer接口，定义一个play方法。
  • 定义被适配者：创建一个Mp3AndWavPlayer类，实现AudioPlayer接口，仅支持MP3和WAV格式。
  • 创建适配器类：创建一个FlacAdapter类，该类实现AudioPlayer接口，并持有Mp3AndWavPlayer实例，通过适配器转换FLAC格式的音频文件为MP3或WAV格式。
  • 客户端使用：客户端代码只需使用AudioPlayer接口，通过适配器来播放不同格式的音频文件。

10.4 代码实现

  • 定义目标接口：
public interface AudioPlayer {
    void play(String audioType, String fileName);
}
  • 定义被适配者：
public class Mp3AndWavPlayer implements AudioPlayer {
    @Override
    public void play(String audioType, String fileName) {
        if ("mp3".equalsIgnoreCase(audioType) || "wav".equalsIgnoreCase(audioType)) {
            System.out.println("Playing " + audioType + " file. Name: " + fileName);
        } else {
            System.out.println("Unsupported audio format.");
        }
    }
}
  • 创建适配器类：
public class FlacAdapter implements AudioPlayer {
    private final Mp3AndWavPlayer mp3AndWavPlayer;

    public FlacAdapter(Mp3AndWavPlayer mp3AndWavPlayer) {
        this.mp3AndWavPlayer = mp3AndWavPlayer;
    }

    @Override
    public void play(String audioType, String fileName) {
        if ("flac".equalsIgnoreCase(audioType)) {
            // 假设有一个方法可以将FLAC转换为MP3
            String convertedFileName = convertFlacToMp3(fileName);
            mp3AndWavPlayer.play("mp3", convertedFileName);
        } else {
            mp3AndWavPlayer.play(audioType, fileName);
        }
    }

    private String convertFlacToMp3(String fileName) {
        // 假设这是FLAC到MP3的转换逻辑
        return "converted-" + fileName + ".mp3";
    }
}
  • 客户端使用：
public class AudioPlayerTestDrive {
    public static void main(String[] args) {
        Mp3AndWavPlayer mp3AndWavPlayer = new Mp3AndWavPlayer();
        AudioPlayer flacAdapter = new FlacAdapter(mp3AndWavPlayer);

        flacAdapter.play("mp3", "song.mp3"); // 正常播放
        flacAdapter.play("wav", "song.wav"); // 正常播放
        flacAdapter.play("flac", "song.flac"); // 通过适配器转换后播放
    }
}

10.5 测试验证

  • 单元测试：编写单元测试来验证适配器是否正确地转换了FLAC文件并播放。
  • 集成测试：确保适配器与其他系统组件一起正常工作。

10.6 总结反思

  • 优点：通过适配器模式，我们成功地扩展了多媒体播放器的功能，使其能够播放FLAC格式的音频文件。
  • 不足之处：适配器增加了系统的复杂性，特别是转换逻辑可能会影响性能。
  • 改进方向：可以考虑使用缓存机制来存储已转换的音频文件，以减少重复的转换工作。

11. 常见问题解答

如何决定何时使用适配器模式？

  • 接口不兼容：当你遇到两个类或接口不能直接协作，因为它们的接口不兼容时，适配器模式是一个很好的解决方案。
  • 重用现有类：如果你希望重用一些现有的类，但它们的接口与你的系统不兼容，适配器模式可以帮助你解决这个问题。
  • 扩展性和灵活性：当你预计系统在未来需要支持更多的接口时，适配器模式提供了一种灵活的方式来实现这一点。
  • 单一职责原则：通过适配器模式，你可以让每个类专注于自己的职责，这符合单一职责原则。

适配器模式是否适用于所有类型的接口不兼容问题？

  • 并非所有情况都适用：虽然适配器模式是一种强大的工具，但它并不总是解决接口不兼容问题的最佳方案。
  • 考虑场景：在选择适配器模式之前，你应该考虑场景的具体需求。如果问题可以通过简单的重构或设计模式的组合来解决，那么可能不需要使用适配器模式。
  • 评估成本效益：引入适配器模式会增加系统的复杂性，所以在使用之前需要权衡其带来的好处与增加的复杂性之间的关系。

12. 结论

适配器模式的总结

  • 核心思想：适配器模式的核心思想是通过引入适配器类来解决接口不兼容的问题，从而使原本无法协作的不同类可以一起工作。
  • 应用场景：适配器模式适用于需要重用现有类但接口不兼容的情况，以及需要扩展系统以支持更多接口的情况。
  • 实现方式：适配器模式可以通过类适配器模式、对象适配器模式或接口适配器模式来实现。
  • 优缺点：适配器模式的优点在于提高了代码的灵活性和可扩展性，但可能会增加系统的复杂性，并可能导致一定的性能开销。

后续学习建议

  • 深入研究其他设计模式：除了适配器模式之外，还有许多其他设计模式，如桥接模式、装饰者模式、代理模式等，值得进一步探索。
  • 实践应用：通过实际项目来练习适配器模式的应用，可以帮助你更好地理解和掌握这一模式。
  • 阅读经典文献：《设计模式：可复用面向对象软件的基础》是一本经典的参考书，书中详细介绍了包括适配器模式在内的多种设计模式。
  • 参与社区讨论：加入设计模式相关的技术社区和论坛，参与讨论和分享经验，可以让你获得新的见解和灵感。

本文详细介绍了23种设计模式的基础知识，帮助读者快速掌握设计模式的核心概念，并找到适合实际应用的具体模式：
【设计模式入门】设计模式全解析：23种经典模式介绍与评级指南（设计师必备）

无理 Java
关注
  • 11
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式探索：适配器模式
搬砖的小熊猫的博客
07-09 1261
将一个类的接口转换为客户期望的另一个接口，适配器可以让不兼容的两个类一起协同工作。适配器模式的主要作用是把原本不兼容的接口，通过适配修改做到统一，使得用户方便使用。比如，万能充电器和多接口数据线都是为了适配各种不同的接口。为什么要转换接口？原接口和目标接口都已经存在，不易修改接口代码。抽象接口希望复用已有组件的逻辑。优点：解耦合: 适配器模式允许两个没有直接关联的类协同工作，降低了它们之间的耦合度。提高复用性: 通过适配器，可以重用现有的类，而不需要修改它们的代码。统一接口。
设计模式系列：搞懂适配器模式，实现接口间不同的变换
风雨编码路的博客
03-26 1806
适配器模式的定义：将一个类的接口转换成客户端需要的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。属于结构型设计模式。 适配器模式分为类适配器、对象适配器和接口适配器。 适配器模式的结构：适配器模式（Adapter）包含3个主要角色。 目标（Target）角色：系统业务所期待的接口，它可以是抽象类或接口。 适配者（Adaptee）角色：等待被适配的对象。 适配器（Adapter）类：它是一个转换器，把适配者角色转换成目标角色。
适配器模式：一招搞定接口不兼容
qq_36756227的博客
05-24 1186
适配器模式（Adapter Pattern）是一种结构型设计模式，它允许将一个类的接口转换成客户端所期望的另一个接口，使得原本由于接⼝不兼容⽽不能⼀起⼯作的那些类可以⼀起⼯作。通俗来讲，就是通过适配器来连接两个不兼容的接口，让客户端通过调用一个通用的接口，而间接实现对其他功能接口的调用。打个形象的比喻，适配器就好比我们生活中的三充数据线，可以适配不同的充电接口。
2.设计模式之适配器模式：适配老版本接口和第三方接口
qq_33252988的博客
03-15 1210
adapter 场景介绍: (1)假设我们做了一个第一版的一个系统，这个系统里有一个接口和实现类 (2)接着我们开始做的第二个版本，这个系统我们定义了一个新的接口，和新的实现类 (3)但是我们同时在第二个版本的系统中，也要使用第一版系统中定义的那个老接口和老实现类 不用设计模式的实现 package com.zhss.designpattern.adapter; /** * 不用设计模式的实现 * */ public class WithoutAdapterPatternDemo { publ
适配器模式：让不兼容的接口协同工作
果酱 の 博客
07-12 4479
适配器模式是一种将一个类的接口转换为另一个接口的设计模式。它允许不兼容的接口协同工作，使得原本由于接口不匹配而无法在一起工作的类能够合作。适配器模式通过创建一个适配器类，将客户端的调用转发给适配者类，从而实现接口的适配。适配器模式是一种结构型设计模式，它允许将一个类的接口转换为客户端所期望的另一个接口。通过适配器模式，我们可以让不兼容的接口协同工作，实现接口的适配。适配器模式具有兼容性、复用性和灵活性的优点，适用于需要适配接口的场景。希望本文对您理解适配器模式有所帮助！
Python 程序语言设计模式思路-结构型模式：适配器模式-将不兼容的接口转换为可兼容的接口
05-20
适配器模式（Adapter Pattern）是一种结构型设计模式，旨在将一个类的接口转换为客户端期望的另一个接口，从而使原本由于接口不兼容而无法一起工作的类能够协同工作。适配器模式通过引入一个适配器类，解决了接口不...
设计模式：结构型-适配器模式
08-31
适配器模式是一种结构型设计模式，用于解决两个不兼容接口之间的问题，它充当了两者之间的桥梁。适配器模式可以分为三种类型：类适配器模式、对象适配器模式和接口适配器模式。 类适配器模式中，适配器类通过继承...
深入理解JavaScript系列（39）：设计模式之适配器模式详解
12-09
适配器模式（Adapter）是将一个类（对象）的接口（方法或属性）转化成客户希望的另外一个接口（方法或属性），适配器模式使得原本由于接口不兼容而不能一起工作的那些类（对象）可以一些工作。速成包装器（wrapper）...
.NET设计模式（8）：适配器模式（AdapterPattern）
01-30
这种情况下，就需要采用一种设计模式——**适配器模式**（Adapter Pattern），来解决接口不兼容的问题，从而使得这些优秀的组件可以在新的环境中被重用。 #### 适配器模式的目的与作用 适配器模式的核心目标是**将...
Java设计模式（适配器模式）
qq_63538423的博客
08-06 247
将一个类的接口转换成客户希望的另一个接口。适配器模式让那些接口不兼容的类可以一起工作。
C++进阶:设计模式___适配器模式
jllws1的博客
08-03 1033
在C++的基础语法的学习后,更进一步为应用场景多写代码.其中设计模式是有较大应用空间.
设计模式之备忘录模式
yimeixiaolangzai的博客
08-07 302
备忘录模式提供了一种方式，使得对象能保存其当前状态，并在未来某个时刻恢复到这个状态。这种模式通过使用三个关键组件实现：发起人（Originator）、备忘录（Memento）和看护者（Caretaker）。备忘录模式是一种非常有用的设计模式，它可以帮助我们有效地保存和恢复对象的状态，而不破坏对象的封装性。通过实践和应用备忘录模式，开发者可以更容易地实现如撤销功能这类需求，增强用户体验和系统的可靠性。在设计需要状态恢复功能的系统时，备忘录模式无疑是一个值得考虑的选择。
设计模式 - 工厂模式
like455的博客
08-04 907
提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
单例模式：确保唯一实例的设计模式
m0_62056231的博客
08-07 387
在学习框架和大型项目开发时，我们常常会遇到“单例模式”这个词。虽然它时常被提及，但往往没有详细讲解。为了搞懂单例模式的真正意义以及它在开发中的应用，我查阅了一些资料并总结了这篇博客。希望通过这篇文章，能够帮助大家更好地理解单例模式，并在实际开发中得心应手地运用它。单例模式是一种创建型设计模式，其目的是确保一个类只有一个实例，并且提供一个全局的访问点。简单来说，就是一个类的实例是唯一的，所有请求这个实例的地方都得到相同的对象。可以将单例模式比作家庭中的家庭医生：全家只有一个医生，所有的健康问题都由他来处理。
C++｜设计模式（八）｜⭐️工厂模式？错！是工厂模式群！
糖炒栗子
08-02 947
首先我们按照与 Employee 类相同的方式来创建所有不同项目对应的基类（父类）Project，在这个类中我们还定义了与项目相关的接口 assignTo ，这个接口可以将某个项目指派给对应账户ID的员工，还是相同的方式我们定义 ITProject 与 UIProject 这两个不同项目的子类，并提供 assignTo 接口的不同实现。
设计模式 由浅入深（待完结）
最新发布
Whale_XH的Blog
08-07 120
设计模式是指在软件开发中，经过验证的，解决方案。
【设计模式】设计模式之观察者模式
Patrick_yuxuan的博客
08-02 906
观察者模式（Observer Pattern）是一种设计模式它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象使得当一个对象的状态发生改变时，其依赖的其他对象会被自动通知和更新。// 抽象观察者// 抽象主题角色类// 添加订阅者（添加观察者对象）//删除订阅者//通知订阅者更新消息。
设计模式实战：游戏开发的设计与实现
qq_40254606的博客
08-06 346
通过本项目，我们综合应用了状态模式、策略模式和原型模式，解决了游戏开发中的角色状态管理、技能策略和角色复制需求。通过这些模式，我们实现了系统模块的解耦和灵活扩展，使得代码结构更加清晰、易于维护。
Java：设计模式（单例，工厂，代理，命令，桥接，观察者）
燕双嘤
08-02 979
3w字吐血整理，Java设计模式（工厂模式（简单工厂模式&抽象工厂模式）、单例模式、生成器模式和原型模式、适配器模式、桥接模式、组合器模式、装饰器模式、门面模式、享元模式和代理模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板模式和访问者模式）。包括：基础知识，底层原理，代码复现，面试难点，刁钻问题解答。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值