I walk very slowly, but I never walk backwards 

设计模式 - 适配者模式

---

寂然

大家好，我是寂然，接下来，我们开启第四篇章 - 结构型模式的学习，本节课，我们开启来聊结构型模式的第一种适配器模式，闲言少叙，我们先来看个生活中的适配器案例

生活中的适配器案例

我们先来看个生活中的案例，世界上的用电插头存在着多种标准，中国是三个扁头，澳大利亚也在使用这种标准的插头，而美国的插头就是一圆两扁，所以如果我们去美国旅游的话，国内的插头肯定没办法使用了，我们一般都会购买多功能转接插头，做一个转换，来适配美国的插头标准，那其实多功能转接插头就扮演着适配器的角色

---

---

基本介绍

适配器模式（Adapter Pattern）将某个类的接口转换成客户端期望的另一个接口表示，主的目的是兼容性，让原本因接口不匹配不能一起工作的两个类可以协同工作，其别名为包装器(Wrapper)

适配器分类

适配器模式属于结构型模式，主要分为三类：

• 类适配器模式

• 对象适配器模式

• 接口适配器模式

工作原理

适配器模式：将一个类的接口转换成另一种接口，让原本接口不兼容的类可以兼容

Adapter 适配器设计模式中有 3 个重要角色：

被适配者 Adaptee，适配器 Adapter 和目标对象 Target

• 从用户的角度看不到被适配者，是解耦的

• 用户调用适配器转化出来的目标对象方法，适配器再调用被适配者的相关接口方法

• 用户收到反馈结果，感觉只是和目标对象交互 ，类图如下所示

• • *

---

类适配器

基本思路：Adapter 类，通过继承Adaptee类，实现 Target 类接口，完成 Apdaptee -> Target 的适配

案例演示 - 电压问题

举个较为简单和合适的案例，我们经常使用的手机或电脑充电器，也属于适配器，它将220V的交流电（AC）转换为手机可用的5V直流电（DC），那AC也就相当于被适配者，DC相当于目标对象，充电器扮演了适配器的角色，OK，那我们以手机充电器为例，演示类适配器模式

//被适配者：220v交流电
public class AC {
​
 public int outputAC() {
​
 int srcV = 220; //
​
 System.out.println( srcV + "V交流电");
​
 return srcV;
 }
}
​
//目标对象：5V直流电
public interface DC {
​
 int outputDC();
}
​
//适配器：手机充电器
public class IphoneAdapter extends AC implements DC{
​
 @Override
 public int outputDC() {
​
 //获取到220V交流电
 int srcV = outputAC();
​
 //模拟适配器转化过程，转化为5V直流电
 int targetV = srcV / 44;
​
​
 return targetV;
 }
}
​
//手机
public class Iphone {
​
 //手机充电方法
 public void charging(DC dc){
​
 if (dc.outputDC() == 5){ //转换成功
​
 System.out.println("电压为5v,手机正在充电中");
 } else {
​
 System.out.println("注意安全.....");
 }
​
 }
}
​
//客户端
public class Client {
​
 public static void main(String[] args) {
​
 new Iphone().charging(new IphoneAdapter());
​
 }
}

可以看到，类适配器是通过继承Adaptee 类，实现 Target 接口的方式实现适配的，由于他继承了Adaptee 类，所以他可以根据需求重写 Adaptee 类的方法，使得适配器的灵活性增强了，但是，由于Java单继承的机制，这就要求目标对象 Target必须是接口，有一定的局限性

对象适配器

基本思路：和类适配器模式相同，但是对 Adapter 类做修改，不去继承被适配者Adaptee，而是持有Adaptee类的实例，实现 Target 类接口，完成 Apdaptee -> Target 的适配，以解决兼容性的问题

• 根据合成复用原则，在系统中尽量使用关联关系来替代继承关系

• 对象适配器是适配器模式中常用的一种

同样，我们用上面电压问题的案例，来演示对象适配器模式的使用

//被适配者：220V交流电
public class AC {
​
 public int outputAC() {
​
 int srcV = 220; //
​
 System.out.println( srcV + "V交流电");
​
 return srcV;
 }
}
​
//目标对象：5V直流电
public interface DC {
​
 int outputDC();
}
​
//适配器：手机充电器
public class IphoneAdapter implements DC {
​
 private AC ac; //持有被适配者对象，而不再是继承
​
 public IphoneAdapter(AC ac){ //构造器传值

 this.ac = ac;
 }
​
 @Override
 public int outputDC() {
​
 //获取到220V交流电
 int srcV = this.ac.outputAC();
​
 //模拟适配器转化过程，转化为5V直流电
 int targetV = srcV / 44;
​
​
 return targetV;
 }
}
//手机
public class Iphone {
​
 //手机充电方法
 public void charging(DC dc){
​
 if (dc.outputDC() == 5){ //转换成功
​
 System.out.println("电压为5v,手机正在充电中");
 } else {
​
 System.out.println("注意安全.....");
 }
​
 }
}
//客户端
public class Client {
​
 public static void main(String[] args) {
​
 new Iphone().charging(new IphoneAdapter(new AC()));
​
 }
}

对象适配器和类适配器其实算是同一种思想，只不过实现方式针对类适配器的局限性进行了优化，根据合成复用原则，用关联关系替代了继承，不再要求目标对象 Target 必须是接口，使用成本更低，更加灵活

接口适配器

一些书籍也把接口适配器模式称之为缺省适配器模式，他的基本思想是这样的：

当不需要全部实现接口提供的方法时，可以先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现，即（空方法），那么该抽象类的子类可以有选择的覆盖父类的某些方法来实现需求
适用于对于一个接口，不需要使用其所有方法的情况

案例改进 - 电压问题

为了演示适配器模式，我们对上面电压问题的案例进行简易升级，假设现在我的目标接口有多个方法，可以输出5V，12V，20V的电压，按照正常逻辑，设计一个适配器去实现这个接口，显然，需要实现该目标接口的所有方法，但是，现在我们实际情况中，只需要使用其中的5V直流电给手机进行充电，不需要使用这个接口的所有方法

---

因此，可以设计一个中间类去把目标接口的所有方法空实现，然后适配器类再去继承这个中间类，选择性重写我所需要的方法，不久OK了嘛，代码示例如下图所示：

//被适配者：220V交流电
public class AC {
​
 public int outputAC() {
​
 int srcV = 220; //
​
 System.out.println( srcV + "V交流电");
​
 return srcV;
 }
}
​
//目标接口，有多个方法
public interface IDC {
​
 int output5V();
​
 int output12V();
​
 int output20V();
}
​
//中间的抽象类，空实现所有方法
public class DefaultAdapter implements IDC{
​
 @Override
 public int output5V() {
 return 0;
 }
​
 @Override
 public int output12V() {
 return 0;
 }
​
 @Override
 public int output20V() {
 return 0;
 }
}
​
//手机充电器只需要实现5V的方法即可，其他的没必要
public class IphoneAdapter extends DefaultAdapter {
​
 private AC ac;
​
 public IphoneAdapter(AC ac) {
 this.ac = ac;
 }
​
 @Override
 public int output5V() { //选择性重写
​
 //拿到220V的交流电
 int srcV = this.ac.outputAC();
​
 //模拟适配器转化过程，转化为5V直流电
 int targetV = srcV / 44;
​
 return targetV;
​
 }
​
 public static void main(String[] args) {
​
 IphoneAdapter iphoneAdapter = new IphoneAdapter(new AC());
​
 System.out.println("手机充电器的电压为 " + iphoneAdapter.output5V());
​
 }
}

实现了案例需求，大家回头再看接口适配器模式的基本思想，和案例需求相结合，对他的理解会更深入一些

JDK IO源码分析

在java jdk中，适配器模式使用场景很多，例如java.io.InputStreamReader、java.io.OutputStreamWriter 等，我们通过一个简单的Demo，来分析下 InputStreamReader 中的适配器模式

/**
 * @Classname InputStreamReaderDemo
 * @Created by 寂然
 * @Description InputStreamReader字节输入流转化为字符输入流
 */
public class InputStreamReaderDemo {
​
 public static void main(String[] args) throws IOException {
 //字节输入流
 InputStream is = System.in ;
​
 Reader r = new InputStreamReader(is) ;
​
 FileWriter fw = new FileWriter("d.txt") ;
​
 char[] chs = new char[1024] ;
​
 int len ;
​
 while((len = r.read(chs))!=-1){
​
 fw.write(chs, 0, len);
​
 fw.flush();
 }
​
 r.close();
​
 fw.close();
 }
}

下面我们通过 源码来进行分析

 * @see java.nio.charset.Charset
 *
 * @author      Mark Reinhold
 * @since       JDK1.1
 */
​
public class InputStreamReader extends Reader {
​
 private final StreamDecoder sd;
​
 /**
 * Creates an InputStreamReader that uses the default charset.
 *
 * @param  in   An InputStream
 */
 //构造函数，传入InputStream 对象in，并且关联在StreamDecoder sd对象中
 public InputStreamReader(InputStream in) {
 super(in);
 try {
 sd = StreamDecoder.forInputStreamReader(in, this, (String)null); // ## check lock object
 } catch (UnsupportedEncodingException e) {
 // The default encoding should always be available
 throw new Error(e);
 }
 }

 //适配Reader类中字符读取操作，调用sd中字节读取转化为字符读取。
 public int read() throws IOException {
 return sd.read();
 }

}

具体角色分析：

• Reader 类对应目标对象 Target

• InputStreamReader 类对应适配器 Adapter

• InputStream 对应被适配者 Adaptee

可以看到，这里使用了适配器模式，InputStreamReader 将Reader 和InputStream 适配起来，在read() 方法中适配Reader类中字符读取操作，调用sd对象中的字节读取转化为了字符读取

下节预告

OK，到这里，适配器模式的相关内容就结束了，下一节，我们开启桥接模式的学习，希望大家能够一起坚持下去，真正有所收获，就像开篇那句话，我走的很慢，但是我从来不后退，哈哈，那我们下期见~