适配器模式

📖 介绍

适配器模式（Adapter / Wrapper）是一种 结构型模式。

通过适配器模式，可以将一个类A的接口，转化成一个类B，以满足一些方法的调用。

如类A是一个第三方、遗留类等，已经被其他地方使用，无法更改，通过适配器模式的思想，通过一个中间的类，封装复杂的转化过程，转换为需要的类型。

🔖 生活中的插座，各个国家标准不同，可以通过一个转接器，适配不同的插口
🔖 ARM CPU 适配 X86 应用的转译
🔖 Linux -> Wine / 虚拟机 -> 运行 Windows 应用

🎈 实现方式

🎗️ 实现一个中间类，实现/继承需要的类型
🎗️ 将需要被转换的类A，作为中间类的成员对象
🎗️ 在类A中实现相关方法，进行适配
🎗️ 最后，所有的相关工作，都会被委托给中间类

☕ Java 中的适配器模式

当我们现在的数据是数组类型时 String[]，现在调用的方法需要传入 List<String> 对象，可以通过工具类进行转换。

1
2
3
4
// String[] ---Arrays.asList()---> List<String>
// Arrays.asList() 相当于一个 Adapter
String[] data = new String[] {"one", "two", "three"};
List<String> dataList = Arrays.asList(data);  // 这里的 List 是一个内部类

🛠️ 实现

1
2
3
4
5
6
7
class Task implement Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("这是一个现有的任务");
        return "这是一个现有的任务";
    }
}

1
2
3
4
5
// 现在某处，需要使用 Thread 运行线程方法
// ⚠ new Thread(new Runnable()) 不能接收 Callable 对象
// 需要使用适配器模式，将 Callable -----> Runnable
Callable<String> task = new Task();
new Thread(new RunnableAdapter(task)).start(); 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
// 1) 实现目标接口 Runnable
// 2) 在目标接口中，持有 Callable 对象，对其进行适配
// 3) 在目标接口的方法内部，调用待转换的方法
public class RunnableAdapter implements Runnable {
    private Callable<?> callable;

    public RunnableAdapter(Callable<?> callable) {
        this.callable = callable;
    }

    @Override
    public void run() {
        try {
            callable.call();
        } catch (Exception e) {
            throw new RuntimeException;
        }
    }
}