Java案例中的适配器模式怎么写？

wen java案例 2026-06-18 4

Java案例中的适配器模式：从理论到实战的完整解析

目录导读

适配器模式的核心概念
为什么需要适配器模式？一个真实痛点
适配器模式的三种实现方式（含Java代码）
- 1 类适配器（继承方式）
- 2 对象适配器（组合方式）
- 3 接口适配器（缺省适配）
经典案例：日志系统兼容性改造
实战问答：开发中最常见的3个误区
适配器模式 vs 其他设计模式对比
SEO优化总结：何时使用适配器模式

适配器模式的核心概念

适配器模式（Adapter Pattern）属于结构型设计模式，它的作用是将一个类的接口转换成客户期望的另一个接口,就是让原本不兼容的类可以协同工作。

Java案例中的适配器模式怎么写？

本质： 通过一个中间层（适配器），将“源接口”转换为“目标接口”。

在Java案例中，适配器模式最常见的应用场景是：老系统接口与新系统接口不匹配、第三方库接口与自身业务接口不一致、需要复用现有类但接口不符合需求。

为什么需要适配器模式？一个真实痛点

场景描述：
假设你负责一个电商系统，早期使用OldLogger类记录日志，它有一个log(String message)方法，现在引入了第三方日志框架AdvancedLogger，它使用writeLog(LogLevel level, String content)方法。

如果没有适配器，你需要修改所有调用OldLogger的代码，这会导致高耦合和大量修改，适配器模式正好解决这个问题：在不修改原有类的前提下，让新接口与旧接口兼容。

适配器模式的三种实现方式（含Java代码）

1 类适配器（继承方式）

原理： 适配器同时继承目标接口和源类,通过继承源类的方法实现适配。

// 1. 目标接口（客户期望的接口）
public interface LogTarget {
    void log(String message);
}
// 2. 源类（需要被适配的类）
public class AdvancedLogger {
    public void writeLog(LogLevel level, String content) {
        System.out.println("[" + level + "] " + content);
    }
}
// 3. 类适配器
public class ClassAdapter extends AdvancedLogger implements LogTarget {
    @Override
    public void log(String message) {
        // 将目标接口的方法委托给源类
        writeLog(LogLevel.INFO, message);
    }
}
// 4. 客户端使用
public class Client {
    public static void main(String[] args) {
        LogTarget target = new ClassAdapter();
        target.log("This is a test"); // 输出: [INFO] This is a test
    }
}

优点： 代码简洁，无需额外对象。
缺点： 由于Java单继承限制,适配器只能继承一个源类。

2 对象适配器（组合方式）★推荐

原理： 适配器持有源类的实例，通过组合方式调用源类方法,这是最常用的方式。

// 源类不变，重写适配器
public class ObjectAdapter implements LogTarget {
    private AdvancedLogger advancedLogger; // 持有源类实例
    public ObjectAdapter(AdvancedLogger advancedLogger) {
        this.advancedLogger = advancedLogger;
    }
    @Override
    public void log(String message) {
        advancedLogger.writeLog(LogLevel.INFO, message);
    }
}
// 客户端
public class Client {
    public static void main(String[] args) {
        AdvancedLogger logger = new AdvancedLogger();
        LogTarget target = new ObjectAdapter(logger);
        target.log("Test message");
    }
}

优点： 灵活，可适配多个源类，符合“组合优先于继承”原则。
缺点： 需要额外创建适配器对象。

3 接口适配器（缺省适配）

适用场景： 当目标接口包含大量方法，但客户端只需要其中一部分时,通过抽象类提供默认空实现。

// 包含多个方法的接口
public interface ManyMethods {
    void methodA();
    void methodB();
    void methodC();
}
// 抽象适配器（提供空实现）
public abstract class AbstractAdapter implements ManyMethods {
    @Override
    public void methodA() {}
    @Override
    public void methodB() {}
    @Override
    public void methodC() {}
}
// 具体实现类只重写需要的方法
public class ConcreteService extends AbstractAdapter {
    @Override
    public void methodA() {
        System.out.println("Only need methodA");
    }
}

经典案例：日志系统兼容性改造

需求： 公司有两个项目，项目A使用OldLogger（只有logInfo()方法），项目B引入新框架Slf4jLogger（使用info(String)方法）,现需要统一日志格式。

原始代码：

// 旧系统
class OldLogger {
    public void logInfo(String msg) {
        System.out.println("OLD: " + msg);
    }
}
// 新系统
class Slf4jLogger {
    public void info(String msg) {
        System.out.println("SLF4J: " + msg);
    }
}

适配器实现：

// 统一目标接口
public interface LoggerAdapter {
    void log(String message);
}
// 旧系统适配器
public class OldLoggerAdapter implements LoggerAdapter {
    private OldLogger oldLogger;
    public OldLoggerAdapter(OldLogger oldLogger) {
        this.oldLogger = oldLogger;
    }
    @Override
    public void log(String message) {
        oldLogger.logInfo(message);
    }
}
// 新系统适配器
public class Slf4jAdapter implements LoggerAdapter {
    private Slf4jLogger slf4jLogger;
    public Slf4jAdapter(Slf4jLogger slf4jLogger) {
        this.slf4jLogger = slf4jLogger;
    }
    @Override
    public void log(String message) {
        slf4jLogger.info(message);
    }
}
// 客户端统一调用
public class Application {
    public static void main(String[] args) {
        LoggerAdapter oldAdapter = new OldLoggerAdapter(new OldLogger());
        LoggerAdapter newAdapter = new Slf4jAdapter(new Slf4jLogger());
        oldAdapter.log("Startup");
        newAdapter.log("Shutdown");
    }
}

效果： 所有日志调用统一使用LoggerAdapter.log(),无需关心底层实现。

实战问答：开发中最常见的3个误区

Q1：适配器模式与代理模式有什么区别？

A：

适配器模式关注接口转换，目的是让不兼容的接口协同工作。
代理模式关注控制访问，目的是在调用前后做额外处理（如日志、权限）。
简单判断：如果是为了“让A能调用B的方法”，用适配器；如果是“在调用A前后做点事”,用代理。

Q2：对象适配器与类适配器该如何选择？

A：

优先使用对象适配器（组合方式），因为它更灵活，不占用继承名额，且可以适配多个源类。
只有在源类需要被完全重写且无需扩展时，才考虑类适配器，Java案例中90%的场景用对象适配器。

Q3：适配器模式会导致系统复杂度增加吗？

A：
合理使用不会，它增加的复杂度是局部且可控的，换来的是解耦和可维护性，但切勿滥用——如果接口本身可以通过重构统一,直接修改源类比引入适配器更好。

适配器模式 vs 其他设计模式对比

模式	核心目的	典型场景	结构
适配器	接口转换	老系统集成、第三方库适配	持有源类或继承
装饰器	动态扩展功能	IO流包装、权限校验	同接口叠加
代理	控制访问	远程调用、懒加载	同接口代理
外观	简化复杂子系统	系统入口封装	组合多个子系统