适配器模式
1）概述
将一个接口转换成用户希望的另一个接口，使接口不兼容的那些类可以一起工作，其别名为包装器(Wrapper)；
在适配器模式中，通过增加一个新的适配器类来解决接口不兼容的问题，使得原本没有任何关系的类可以协同工作。
注意：在适配器模式中提及的接口是指广义的接口，可以表示一个方法或者方法的集合。
2）分类
1.对象适配器
在对象适配器模式中，适配器与适配者之间是关联关系。
2.类适配器
在类适配器模式中，适配器与适配者之间是继承（或实现）关系。
3）对象适配器模式
1.结构图
2.角色
● Target（目标抽象类）：定义客户所需接口，可以是一个抽象类或接口，也可以是具体类。
● Adapter（适配器类）：可以调用另一个接口，作为一个转换器，对Adaptee和Target进行适配，适配器类是适配器模式的核心，在对象适配器中，它通过继承Target并关联一个Adaptee对象使二者产生联系。
● Adaptee（适配者类）：即被适配的角色，它定义了一个已经存在的接口，这个接口需要适配，适配者类一般是一个具体类，包含了客户希望使用的方法，在某些情况下可能没有适配者类的源代码。
3.Adapter代码案例
class Adapter extends Target {
private Adaptee adaptee; //维持一个对适配者对象的引用
public Adapter(Adaptee adaptee) {
this.adaptee=adaptee;
}
public void request() {
adaptee.specificRequest(); //转发调用
}
}
4）案例-完整解决方案
1.结构图
ScoreOperation为抽象目标接口，QuickSort和BinarySearch类充当适配者，OperationAdapter充当适配器。
2.代码如下
目标抽象接口-ScoreOperation
//抽象成绩操作类：目标接口
interface ScoreOperation {
public int[] sort(int[] array); //成绩排序
public int search(int[] array, int key); //成绩查找
}
适配者
//二分查找类：适配者
public class BinarySearch {
public int binarySearch(int array[], int key) {
int low = 0;
int high = array.length - 1;
while (low <= high) {
int mid = (low + high) / 2;
int midVal = array[mid];
if (midVal < key) {
low = mid + 1;
} else if (midVal > key) {
high = mid - 1;
} else {
return 1; //找到元素返回1
}
}
return -1; //未找到元素返回-1
}
}
-------------------------------------------------------
//快速排序类：适配者
public class QuickSort {
public int[] quickSort(int[] array) {
sort(array, 0, array.length - 1);
return array;
}
public void sort(int[] array, int p, int r) {
int q = 0;
if (p < r) {
q = partition(array, p, r);
sort(array, p, q - 1);
sort(array, q + 1, r);
}
}
public int partition(int[] a, int p, int r) {
int x = a[r];
int j = p - 1;
for (int i = p; i <= r - 1; i++) {
if (a[i] <= x) {
j++;
swap(a, j, i);
}
}
swap(a, j + 1, r);
return j + 1;
}
public void swap(int[] a, int i, int j) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
适配器-OperationAdapter
//操作适配器：适配器
public class OperationAdapter implements ScoreOperation {
private final QuickSort sortObj; //定义适配者QuickSort对象
private final BinarySearch searchObj; //定义适配者BinarySearch对象
public OperationAdapter() {
sortObj = new QuickSort();
searchObj = new BinarySearch();
}
public int[] sort(int[] array) {
return sortObj.quickSort(array); //调用适配者类QuickSort的排序方法
}
public int search(int[] array, int key) {
return searchObj.binarySearch(array, key); //调用适配者类BinarySearch的查找方法
}
}
客户端-Client
public class Client {
public static void main(String[] args) {
ScoreOperation operation;
operation = new OperationAdapter();
int[] scores = {84, 76, 50, 69, 90, 91, 88, 96};
int[] result;
int score;
System.out.println("成绩排序结果：");
result = operation.sort(scores);
//遍历输出成绩
for (int i : scores) {
System.out.print(i + ",");
}
System.out.println();
System.out.println("查找成绩90：");
score = operation.search(result, 90);
if (score != -1) {
System.out.println("找到成绩90。");
} else {
System.out.println("没有找到成绩90。");
}
System.out.println("查找成绩92：");
score = operation.search(result, 92);
if (score != -1) {
System.out.println("找到成绩92。");
} else {
System.out.println("没有找到成绩92。");
}
}
}
5）类适配器模式
1.类适配器模式和对象适配器模式区别
适配器和适配者之间的关系不同：对象适配器模式中适配器和适配者之间是关联关系，而类适配器模式中适配器和适配者是继承关系。
2.结构图
3.代码案例
适配器类实现了抽象目标类接口Target，并继承了适配者类，在适配器类的request()方法中调用所继承的适配者类的specificRequest()方法，实现了适配。
class Adapter extends Adaptee implements Target {
public void request() {
specificRequest();
}
}
注意：
- 由于Java、C#等语言不支持多重类继承，因此类适配器的使用受到很多限制，例如如果目标抽象类Target不是接口，而是一个类，就无法使用类适配器。
- 如果适配者Adaptee为最终(Final)类，也无法使用类适配器，在Java等面向对象编程语言中，大部分情况下使用的是对象适配器，类适配器较少使用。
6）双向适配器
1.概述
在对象适配器中，如果在适配器中同时包含对目标类和适配者类的引用，适配者可以通过它调用目标类中的方法，目标类也可以通过它调用适配者类中的方法，那么该适配器就是一个双向适配器。
2.结构图
3.代码如下
class Adapter implements Target,Adaptee {
//同时维持对抽象目标类和适配者的引用
private Target target;
private Adaptee adaptee;
public Adapter(Target target) {
this.target = target;
}
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
public void request() {
adaptee.specificRequest();
}
public void specificRequest() {
target.request();
}
}
7）缺省适配器
1.概述
当不需要实现一个接口所提供的所有方法时，可先设计一个抽象类实现该接口，并为接口中每个方法提供一个默认实现（空方法），那么该抽象类的子类可以选择性地覆盖父类的某些方法来实现需求。
2.结构图
3.角色分析
● ServiceInterface（适配者接口）：它是一个接口，通常在该接口中声明了大量的方法。
● AbstractServiceClass（缺省适配器类）：它是缺省适配器模式的核心类，使用空方法的形式实现了在ServiceInterface接口中声明的方法，通常将它定义为抽象类，因为对它进行实例化没有任何意义。
● ConcreteServiceClass（具体业务类）：它是缺省适配器类的子类，在没有引入适配器之前，它需要实现适配者接口，因此需要实现在适配者接口中定义的所有方法，而对于一些无须使用的方法也不得不提供空实现。在有了缺省适配器之后，可以直接继承该适配器类，根据需要有选择性地覆盖在适配器类中定义的方法。
8）总结
1.优点
将目标类和适配者类解耦，通过引入一个适配器类来重用现有的适配者类，无须修改原有结构。
增加了类的透明性和复用性，将具体的业务实现过程封装在适配者类中，对于客户端类而言是透明的，而且提高了适配者的复用性，同一个适配者类可以在多个不同的系统中复用。
灵活性和扩展性都非常好，通过使用配置文件，可以很方便地更换适配器，也可以在不修改原有代码的基础上增加新的适配器类，完全符合“开闭原则”。
一个对象适配器可以把多个不同的适配者适配到同一个目标。
可以适配一个适配者的子类，由于适配器和适配者之间是关联关系，根据“里氏代换原则”，适配者的子类也可通过该适配器进行适配。
2.缺点
对于Java、C#等不支持多重类继承的语言，一次最多只能适配一个适配者类，不能同时适配多个适配者。
适配者类不能为最终类，如在Java中不能为final类，C#中不能为sealed类。
在Java、C#等语言中，类适配器模式中的目标抽象类只能为接口，不能为类，其使用有一定的局限性。
与类适配器模式相比，对象适配器要在适配器中置换适配者类的某些方法比较麻烦。
3.适用场景
系统需要使用现有的类，而这些类的接口（如方法名）不符合系统的需要，甚至没有这些类的源代码。
想创建一个可以重复使用的类，用于与彼此之间没有太大关联的一些类一起工作。
