不管你是不是果粉,肯定对 iphone X 都有所耳闻。最近的「掉漆门」和「人脸识别被破解」更是将其推到了风口浪尖上。



但是对于我而言,最难以忍受的还是耳机接口被取消这一改变(自 Iphone 7 开始),你可以想象这样一幅画面:当你开开心心地和小伙伴开着语音吃(song)着(kuai)鸡(di)或者是多人一起上(song)分时——你的电量见底,为了不影响队友(shou)的游戏体验,肯定得充电玩下去。

这时你得面对一个难题:只有一个孔,插耳机还是插电源!?(在没有蓝牙耳机的前提下)



(侵删)

由于生活经常会欺骗我们,以及各种环境因素,所以不是每个人都选择蓝牙耳机(贫穷使我理智)。

是否存在别的解决方法呢?还好有转接线这样的好东西



(侵删)

在编程中,我们也会遇上类似的问题:

  1. 当你想使用一个已经存在的类,而它的接口不符合你的需求;
  2. 你想创建一个可以复用的类,该类可以与其他不相关的类或不可预见的类协同工作;

本文会通过 Adapter Pattern 来探究如何解决这类问题。

本篇文章结构如下:

  • adapter pattern 的概念
  • 实际问题分解
  • Java 实例
  • Scala 实例
  • 总结

概念

适配器模式(Adapter Pattern)有时候也称包装样式或者包装(Wrapper)。定义如下:

将一个类的接口转接成用户所期待的。一个适配使得因接口不兼容而不能在一起工作的类能在一起工作,做法是将类自己的接口包裹在一个已存在的类中。

它解决了什么问题

适配器模式将现有接口转化为客户类所期望的接口,实现了对现有类的复用,它是一种使用频率非常高的设计模式,在软件开发中得以广泛应用,在 Spring 等框架、驱动程序设计(如 JDBC 中的数据库驱动程序)中也使用了适配器模式。

Java 版本

小 A 是个苹果控 + 耳机控,之前买了一款很贵的耳机,对其爱不释手。我们都知道一般耳机接口都是 3.5mm 的。

1
2
3
4
5
6
7
8
9
10
11
public interface PhoneJackInterface {
// 传统的播放音频
void audioTraditionally();
}
public class PhoneJackConnector implements PhoneJackInterface {
@Override
public void audioTraditionally() {
System.out.println("通过 PhoneJack 播放声音");
}
}

iphone 7 之前的 iphone 支持 3.5mm 接口:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Iphone {
private PhoneJackInterface phoneJack;
public Iphone(PhoneJackInterface phoneJack) {
this.phoneJack = phoneJack;
}
// Iphone 具备播放声音的功能
public void play() {
// 通过 3.5mm 接口耳机播放
phoneJack.audioTraditionally();
}
}

这样的情况下,小 A 还可以愉快地听歌:

1
2
3
4
5
// test
PhoneJackInterface phoneJack = new PhoneJackConnector();
Iphone iphone6 = new Iphone(phoneJack);
iphone6.play();
// 控制台输出 “通过 PhoneJack 播放声音”

在 iphone 7 问世后,问题出现了:小 A 发现其不支持 3.5mm 接口 —— 将有线耳机的插口改为了 lightning

1
2
3
4
5
6
7
8
9
10
public interface LightningInterface {
void audioWithLightning();
}
public class LightningConnector implements LightningInterface {
@Override
public void audioWithLightning() {
System.out.println("通过 Lightning 播放声音");
}
}

一边是耳机,一边是手机,这太难以抉择了。但苹果怎么可能没考虑到这点了,可以通过赠送的耳机转接器 —— 将传统的耳机头转为 lightning

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class HeadsetAdapter implements PhoneJackInterface { // 基于传统耳机接口
LightningInterface lightning; // 兼容新接口
/**
* 传入 lightning 接口
* @param lightning
*/
public HeadsetAdapter(LightningInterface lightning) {
this.lightning = lightning;
}
/**
* 对传统接口兼容
*/
@Override
public void audioTraditionally() {
lightning.audioWithLightning();
}
}

类适配器

这样不够简洁,我们可以改一改:

1
2
3
4
5
6
7
public class HeadsetAdapter extends LightningConnector implements PhoneJackInterface {
@Override
public void audioTraditionally() {
// 传统接口兼容 lightning
super.audioWithLightning();
}
}

测试:

1
2
3
4
5
// test
HeadsetAdapter headsetAdapter = new HeadsetAdapter();
Iphone iphone7 = new Iphone(headsetAdapter);
iphone7.play();
// 控制台输出 “通过 Lightning 播放声音”

对象适配器

我们一般将上面的适配器称作「类适配器」,除此之外还有一种 「对象适配器」,我们可以对适配器类进行如下修改:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class ObjectHeadsetAdapter implements PhoneJackInterface { // 基于传统耳机接口
LightningConnector lightning; // 兼容新接口
/**
* 传入 lightning 接口
* @param lightning
*/
public ObjectHeadsetAdapter(LightningConnector lightning) {
this.lightning = lightning;
}
/**
* 对传统接口兼容
*/
@Override
public void audioTraditionally() {
// 使用委托实现兼容
this.lightning.audioWithLightning();
}
}

测试:

1
2
3
ObjectHeadsetAdapter objectHeadsetAdapter = new ObjectHeadsetAdapter(new LightningConnector());
Iphone iphoneX = new Iphone(objectHeadsetAdapter);
iphoneX.play();

对象适配器 vs 类适配器

通过以上简单的例子,相信你对适配器模式有一个大致了解了。「类适配器」与「对象适配器」的区别概括如下:

- 类适配器 对象适配器
创建方式 需要通过创建自身创建出一个新的 Adapter 可以通过已有的 Adapter 对象来转换接口
扩展性 通过 Override 来扩展新需求 因为包含关系所以不能扩展
其他 继承被适配类,所以相对静态 包含被适配类,所以相对灵活

优点

总的来说,适配器模式主要有以下几个优点:

  1. 将目标类和适配者类解耦,通过引入一个适配器类来重用现有的适配者类,无须修改原有结构。
  2. 增加了类的透明性和复用性,将具体的业务实现过程封装在适配者类中,对于客户端类而言是透明的,而且提高了适配者的复用性,同一个适配者类可以在多个不同的系统中复用。
  3. 灵活性和扩展性都非常好,通过使用配置文件,可以很方便地更换适配器,也可以在不修改原有代码的基础上增加新的适配器类,完全符合「开闭原则」。

看完 Java 的实现方式,我们再来看看 Scala 是如何实现的。

Scala 版本

在 Scala 中,由于方便的语法糖,我们并不需要像 Java 那样麻烦,已知传统接口类(此处省略一些接口)

1
2
3
class PhoneJackConnector {
def audioTraditionally = println("通过 PhoneJack 播放声音")
}

如果我们有需要适配的,为其创建一个 trait 即可:

1
2
3
trait Lightning {
def audioWithLightning()
}

其次再新建一个类,继承传统类:

1
2
3
4
5
class HeadsetAdapter extends PhoneJackConnector with Lightning {
override def audioTraditionally: Unit = super.audioTraditionally
override def audioWithLightning: Unit = println("通过 Lightning 播放声音")
}

你会开心的发现:在这个新的类里,我们可以对新老方法一起扩展——在 Java 中,这是「对象适配器」和 「类适配器」比较大的一个劣势。
测试:

1
2
val headsetAdapter = new HeadsetAdapter
headsetAdapter.audioTraditionally

当然,除了这种方式,Scala 里还可以通过隐式转换来实现适配 final 类的适配器:

1
2
3
4
5
6
7
8
9
final class FinalPhoneJackConector {
def audioTraditionally = println("通过 PhoneJack 播放声音")
}
object FinalPhoneJackConector {
implicit class ImplictHeadsetAdapter(phoneJackConnector: FinalPhoneJackConector) extends Lightning {
override def audioWithLightning: Unit = println("通过 Lightning 播放声音")
}
}

测试:

val headsetAdapter = new HeadsetAdapter
headsetAdapter.audioTraditionally

// 隐式
val light: Lightning = new FinalPhoneJackConector
light.audioWithLightning()

Hint: 对于不熟悉 implicit 的朋友可以 看一下这里

总结

光从代码量来说,Scala 简洁比 Java 表现的好太多。

其次,Scala 结合了「类适配器」和「对象适配器」所有的优点,并消除了自身问题。与 Java 相比,Scala 有如下特点:

  1. 与对象适配器一样灵活
  2. 与「类适配器相比」,没有对特定被适配类的依赖
  3. 只适用于不需要动态改变被适配类的情况

源码链接
如有错误和讲述不恰当的地方还请指出,不胜感激!