适配器模式：类适配器与对象适配器的取舍，以及它在 JDK 与 Spring 里的真实形态

import java.math.BigDecimal;

/** ① 目标接口：核心域只认识它 */
interface PaymentGateway {
    void pay(String orderNo, BigDecimal amount);
}

/** ② 被适配者：第三方 SDK，金额用「分」、订单号是 long，签名完全对不上 */
class LegacyPaySdk {
    public boolean doPay(long orderId, long cents, String currency) {
        System.out.printf("[SDK] 订单 %d，金额 %d %s分%n", orderId, cents, currency);
        return true;
    }
}

/** ③ 对象适配器：实现目标接口，持有被适配者，负责翻译 */
class PaySdkAdapter implements PaymentGateway {
    private final LegacyPaySdk sdk;              // 组合，而不是继承

    PaySdkAdapter(LegacyPaySdk sdk) {
        this.sdk = sdk;                          // 运行时可以换实现（甚至可以传子类）
    }

    @Override
    public void pay(String orderNo, BigDecimal amount) {
        long orderId = Long.parseLong(orderNo.substring(2));        // "A-2026" → 2026
        long cents = amount.movePointRight(2).longValueExact();     // 19.90 元 → 1990
        if (!sdk.doPay(orderId, cents, "CNY")) {
            throw new IllegalStateException("支付失败：" + orderNo);  // 把 SDK 的失败码翻译成异常
        }
    }
}

public class ObjectAdapterDemo {
    public static void main(String[] args) {
        PaymentGateway gateway = new PaySdkAdapter(new LegacyPaySdk());
        gateway.pay("A-2026", new BigDecimal("19.90"));   // 调用方全程只认识 PaymentGateway
    }
}

/** 被适配者：老日志实现 */
class OldLogger {
    public void log(int level, String msg) {
        System.out.println("[LV" + level + "] " + msg);
    }
}

/** 目标接口：新代码想用的样子 */
interface AppLogger {
    void info(String msg);
    void error(String msg);
}

/** 类适配器：继承拿到实现，实现接口对上签名 */
class LoggerClassAdapter extends OldLogger implements AppLogger {
    @Override public void info(String msg)  { log(3, msg); }
    @Override public void error(String msg) { log(1, msg); }
}

public class ClassAdapterDemo {
    public static void main(String[] args) {
        AppLogger logger = new LoggerClassAdapter();
        logger.info("启动完成");
        logger.error("连接失败");

        // 代价一：适配器在类型上"是"一个 OldLogger，
        // 调用方可以绕过 Target 直接调老接口 —— "只依赖目标接口"的约束被绕过了
        ((OldLogger) logger).log(2, "绕过目标接口直接调用老方法");
    }
}

/** 新系统这一侧的接口（我们实现的） */
interface NewService {
    void handle(String event);
}

/** 老系统那一侧的接口（别人期待的） */
interface OldListener {
    void onEvent(String code, int type);
}

/** 双向适配器：两边的接口都实现，互相转发 */
class TwoWayAdapter implements NewService, OldListener {
    private final NewService self;        // 新系统一侧
    private final OldListener legacy;     // 老系统一侧

    TwoWayAdapter(NewService self, OldListener legacy) {
        this.self = self;
        this.legacy = legacy;
    }

    @Override public void handle(String event) {          // 新 → 老
        legacy.onEvent(event, 1);
    }

    @Override public void onEvent(String code, int type) { // 老 → 新
        self.handle(code);
    }
}

// 没有 MouseAdapter 的话，只监听一个点击事件也要写满 5 个方法
JButton button = new JButton("点我");
button.addMouseListener(new MouseAdapter() {          // 只覆写关心的那个
    @Override public void mouseClicked(MouseEvent e) {
        System.out.println("clicked");
    }
});

// Java 8 之后：接口可以给 default 实现，这类空实现类就不再必要了
interface MyListener {
    default void onStart() { }
    default void onStop()  { }
    default void onTick()  { }
}

// 字节流 → 字符流：同一个 InputStream，套上适配器就变成 Reader
try (Reader reader = new InputStreamReader(
        new FileInputStream("data.txt"), StandardCharsets.UTF_8)) {
    char[] buf = new char[1024];
    while (reader.read(buf) != -1) {
        // 这里处理的是字符，不再是字节
    }
}

// 数组 → List 视图
List<String> list = Arrays.asList("a", "b", "c");
// list.add("d");   // 运行期抛 UnsupportedOperationException：它只是视图，不是新集合