在现实生活中，经常出现两个对象因接口不兼容而不能在一起工作的实例，这时需要第三者进行适配。例如，讲中文的人同讲英文的人对话时需要一个翻译，用直流电的笔记本电脑接交流电源时需要一个电源适配器，用计算机访问照相机的 SD 内存卡时需要一个读卡器等。
在软件设计中也可能出现：需要开发的具有某种业务功能的组件在现有的组件库中已经存在，但它们与当前系统的接口规范不兼容，如果重新开发这些组件成本又很高，这时用适配器模式能很好地解决这些问题。
模式的定义与特点
适配器模式（Adapter）的定义如下：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。适配器模式分为类结构型模式和对象结构型模式两种，前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少些。
该模式的主要优点如下。
- 客户端通过适配器可以透明地调用目标接口。
- 复用了现存的类，程序员不需要修改原有代码而重用现有的适配者类。
- 将目标类和适配者类解耦，解决了目标类和适配者类接口不一致的问题。
其缺点是：对类适配器来说，更换适配器的实现过程比较复杂。
模式的结构与实现
类适配器模式可采用多重继承方式实现，如 C++ 可定义一个适配器类来同时继承当前系统的业务接口和现有组件库中已经存在的组件接口；Java 不支持多继承，但可以定义一个适配器类来实现当前系统的业务接口，同时又继承现有组件库中已经存在的组件。
对象适配器模式可釆用将现有组件库中已经实现的组件引入适配器类中，该类同时实现当前系统的业务接口。现在来介绍它们的基本结构。
1. 模式的结构
适配器模式（Adapter）包含以下主要角色。
- 目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口。
- 适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口。
- 适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。
类适配器模式的结构图如图 1 所示。
图1 类适配器模式的结构图
对象适配器模式的结构图如图 2 所示。
图2 对象适配器模式的结构图
2. 模式的实现
(1) 类适配器模式的代码如下。
1. package adapter;
2. //目标接口
3. interface Target
4. {
5. public void request();
6. }
7. //适配者接口
8. class Adaptee
9. {
10. public void specificRequest()
11. {
12. System.out.println("适配者中的业务代码被调用！");
13. }
14. }
15. //类适配器类
16. class ClassAdapter extends Adaptee implements Target
17. {
18. public void request()
19. {
20. specificRequest();
21. }
22. }
23. //客户端代码
24. public class ClassAdapterTest
25. {
26. public static void main(String[] args)
27. {
28. System.out.println("类适配器模式测试：");
29. Target target = new ClassAdapter();
30. target.request();
31. }
32. }
程序的运行结果如下：
类适配器模式测试：
适配者中的业务代码被调用！
(2)对象适配器模式的代码如下。
1. package adapter;
2. //对象适配器类
3. class ObjectAdapter implements Target
4. {
5. private Adaptee adaptee;
6. public ObjectAdapter(Adaptee adaptee)
7. {
8. this.adaptee=adaptee;
9. }
10. public void request()
11. {
12. adaptee.specificRequest();
13. }
14. }
15. //客户端代码
16. public class ObjectAdapterTest
17. {
18. public static void main(String[] args)
19. {
20. System.out.println("对象适配器模式测试：");
21. Adaptee adaptee = new Adaptee();
22. Target target = new ObjectAdapter(adaptee);
23. target.request();
24. }
25. }
说明：对象适配器模式中的“目标接口”和“适配者类”的代码同类适配器模式一样，只要修改适配器类和客户端的代码即可。
程序的运行结果如下：
对象适配器模式测试：
适配者中的业务代码被调用！
模式的应用实例
【例1】用适配器模式（Adapter）模拟新能源汽车的发动机。
分析：新能源汽车的发动机有电能发动机（Electric Motor）和光能发动机（Optical Motor）等，各种发动机的驱动方法不同，例如，电能发动机的驱动方法 electricDrive() 是用电能驱动，而光能发动机的驱动方法 opticalDrive() 是用光能驱动，它们是适配器模式中被访问的适配者。
客户端希望用统一的发动机驱动方法 drive() 访问这两种发动机，所以必须定义一个统一的目标接口 Motor，然后再定义电能适配器（Electric Adapter）和光能适配器（Optical Adapter）去适配这两种发动机。
我们把客户端想访问的新能源发动机的适配器的名称放在 XML 配置文件中（点此下载 XML 文件），客户端可以通过对象生成器类 ReadXML 去读取。这样，客户端就可以通过 Motor 接口随便使用任意一种新能源发动机去驱动汽车，图 3 所示是其结构图。
图3 发动机适配器的结构图
程序代码如下：
1. package adapter;
2. //目标：发动机
3. interface Motor
4. {
5. public void drive();
6. }
7. //适配者1：电能发动机
8. class ElectricMotor
9. {
10. public void electricDrive()
11. {
12. System.out.println("电能发动机驱动汽车！");
13. }
14. }
15. //适配者2：光能发动机
16. class OpticalMotor
17. {
18. public void opticalDrive()
19. {
20. System.out.println("光能发动机驱动汽车！");
21. }
22. }
23. //电能适配器
24. class ElectricAdapter implements Motor
25. {
26. private ElectricMotor emotor;
27. public ElectricAdapter()
28. {
29. emotor=new ElectricMotor();
30. }
31. public void drive()
32. {
33. emotor.electricDrive();
34. }
35. }
36. //光能适配器
37. class OpticalAdapter implements Motor
38. {
39. private OpticalMotor omotor;
40. public OpticalAdapter()
41. {
42. omotor=new OpticalMotor();
43. }
44. public void drive()
45. {
46. omotor.opticalDrive();
47. }
48. }
49. //客户端代码
50. public class MotorAdapterTest
51. {
52. public static void main(String[] args)
53. {
54. System.out.println("适配器模式测试：");
55. Motor motor=(Motor)ReadXML.getObject();
56. motor.drive();
57. }
58. }
1. package adapter;
2. import javax.xml.parsers.*;
3. import org.w3c.dom.*;
4. import java.io.*;
5. class ReadXML
6. {
7. public static Object getObject()
8. {
9. try
10. {
11. DocumentBuilderFactory dFactory=DocumentBuilderFactory.newInstance();
12. DocumentBuilder builder=dFactory.newDocumentBuilder();
13. Document doc;
14. doc=builder.parse(new File("src/adapter/config.xml"));
15. NodeList nl=doc.getElementsByTagName("className");
16. Node classNode=nl.item(0).getFirstChild();
17. String cName="adapter."+classNode.getNodeValue();
18. Class c=Class.forName(cName);
19. Object obj=c.newInstance();
20. return obj;
21. }
22. catch(Exception e)
23. {
24. e.printStackTrace();
25. return null;
26. }
27. }
28. }
程序的运行结果如下：
适配器模式测试：
电能发动机驱动汽车！
注意：如果将配置文件中的 ElectricAdapter 改为 OpticalAdapter，则运行结果如下：
适配器模式测试：
光能发动机驱动汽车！
模式的应用场景
适配器模式（Adapter）通常适用于以下场景。
- 以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致。
- 使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同。
模式的扩展
适配器模式（Adapter）可扩展为双向适配器模式，双向适配器类既可以把适配者接口转换成目标接口，也可以把目标接口转换成适配者接口，其结构图如图 4 所示。
图4 双向适配器模式的结构图
程序代码如下：
1. package adapter;
2. //目标接口
3. interface TwoWayTarget
4. {
5. public void request();
6. }
7. //适配者接口
8. interface TwoWayAdaptee
9. {
10. public void specificRequest();
11. }
12. //目标实现
13. class TargetRealize implements TwoWayTarget
14. {
15. public void request()
16. {
17. System.out.println("目标代码被调用！");
18. }
19. }
20. //适配者实现
21. class AdapteeRealize implements TwoWayAdaptee
22. {
23. public void specificRequest()
24. {
25. System.out.println("适配者代码被调用！");
26. }
27. }
28. //双向适配器
29. class TwoWayAdapter implements TwoWayTarget,TwoWayAdaptee
30. {
31. private TwoWayTarget target;
32. private TwoWayAdaptee adaptee;
33. public TwoWayAdapter(TwoWayTarget target)
34. {
35. this.target=target;
36. }
37. public TwoWayAdapter(TwoWayAdaptee adaptee)
38. {
39. this.adaptee=adaptee;
40. }
41. public void request()
42. {
43. adaptee.specificRequest();
44. }
45. public void specificRequest()
46. {
47. target.request();
48. }
49. }
50. //客户端代码
51. public class TwoWayAdapterTest
52. {
53. public static void main(String[] args)
54. {
55. System.out.println("目标通过双向适配器访问适配者：");
56. TwoWayAdaptee adaptee=new AdapteeRealize();
57. TwoWayTarget target=new TwoWayAdapter(adaptee);
58. target.request();
59. System.out.println("-------------------");
60. System.out.println("适配者通过双向适配器访问目标：");
61. target=new TargetRealize();
62. adaptee=new TwoWayAdapter(target);
63. adaptee.specificRequest();
64. }
65. }
程序的运行结果如下：
目标通过双向适配器访问适配者：
适配者代码被调用！
适配者通过双向适配器访问目标：
目标代码被调用！