1、什么是适配器模式
适配器(adapter)模式又叫做包装( wrapper )模式，是由gof提出的23种设计模式中的一种结构型设计模式，adapter模式的设计意图：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。
如图所示，有时，为复用而设计的工具类常常会因为它的接口与专业应用领域所需要的接口不匹配而不能够被复用。
再举个java界面程序开发中的真实案例：我们要设计一个绘图编辑器，这个编辑器允许用户绘制和排列基本图元(线、多边形、正文等)，图元对象的抽象我们用一个 shape 接口来定义，所有的具体图元类型都要实现 shape 接口：lineshape类对应于直线，polygonshape类对应于多边形，textshape类对应于正文，等等。
对于像lineshape和polygonshape这样的基本图元类由于它们的编辑功能本来就很有限，我们很容易就能够实现。但是对于可以显示和编辑正文的textshape子类来说，实现相当困难，因为即使是基本的正文编辑也要涉及到复杂的屏幕刷新和缓冲区管理。同时，外界可能已经存在了一个现成的工具类textview可以用于显示和编辑正文。理想的情况是我们可以复用这个textview类以实现textshape类的功能，不巧的是这个textview类的设计者当时并没有考虑 shape 的存在，导致textview类和 shape的接口互不兼容。
类似地，像上面这种情况，我们希望能够复用textview这样已经存在的类，但此类与我们系统要求的接口不匹配，我们该如何处理呢？
我们可以改变textview类使它兼容shape接口，但前提是必须有这个textview类的源代码。然而即使我们得到了这些源代码，修改textview也是没有什么意义的：因为不应该仅仅为了实现一个应用，就去修改那些为复用而设计的工具箱类，迫使它们实现与特定领域相关的接口(此处是 shape 接口)。
我们可以不用上面的方法，转而定义一个textshape类，由它来适配textview的接口和shape的接口。我们可以用下面两种方法做成这件事：
1)将textshape继承textview并实现shape接口
2)将一个textview实例作为textshape的组成部分，并且使用textview的接口去实现textshape接口。
以上两种方法恰恰对应于adapter模式的两个版本：类的适配器模式和对象的适配器模式。我们将textshape称之为适配器adapter。
从以上案例可以看出，适配器模式其实是一种补偿型模式，在进行全新系统设计的时候很少会用到。而当你遇到以下情况，你或许可以考虑使用adapter模式。
-你想使用一个已经存在的类，而它的接口不符合你的需求。
-你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。
-（仅适用于对象adapter）你想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。
适配器模式分为类的适配器模式(采用继承实现)、对象的适配器模式(采用对象组合方式实现)和接口的适配器模式三种。
类适配器通过继承对一个类与另一个接口进行匹配，如下图所示。
类适配器模式涉及的角色及其职责如下：
客户端(client)类：该类需要与符合条件的特定的接口协同工作。
目标(target)接口类：客户端所需要的接口，在类适配器模式下该角色只能是接口。
适配者(adaptee)类：需要被适配的类，适配者类一般是一个具体类，包含了客户端希望使用的某些业务方法。
适配器(adapter)类：该类对适配者类和目标接口类进行适配，在类适配器模式下通过继承方式实现，即：
adapter 继承 adaptee 并实现 target 接口。
类适配器模式结构示意源代码如下：
target类包含client类所需要的与特定领域相关的接口。
public interface target {
// adaptee适配者有此方法的实现，但方法名可以不同
void specificoperation();
// adaptee适配者没有的其他方法
void otheroperation();
}adaptee类包含了客户端希望使用的某些业务方法，但adaptee类不符合client类所需接口的要求。
public class adaptee {
public void operation() {
system.out.println("执行adaptee的operation()方法...");
}
}adapter类继承adaptee并实现target接口，这样adapter类既符合client类所需接口的要求，又包含了client类希望使用的而原属于adaptee类的业务方法。
public class adapter extends adaptee implements target {
@override
public void specificoperation() {
this.operation();
}
@override
public void otheroperation() {
system.out.println("执行adapter的otheroperation()方法...");
}
}为简单起见我们为client类添加一个clientoperation()方法，该方法需要传入一个target接口对象，在该target接口对象中我们要复用现有的adaptee类的方法。
public class client {
public static void clientoperation(target target) {
target.specificoperation();
target.otheroperation();
}
public static void main(string[] args) {
adapter adapter = new adapter();
clientoperation(adapter);
}
}运行程序打印结果如下：
执行adaptee的operation()方法...
执行adapter的otheroperation()方法...对象适配器通过组合对一个类及其子类与另一个接口进行匹配，如下图所示。
适配器模式涉及的角色及其职责如下：
客户端(client)类：该类需要与符合条件的特定的接口协同工作。
目标(target)接口类：客户端所需要的接口，在对象适配器模式下该角色可以是接口、抽象类或者非final的具体类。
适配者(adaptee)类：需要被适配的类，适配者类一般是一个具体类，包含了客户端希望使用的某些业务方法。
适配器(adapter)类：该类对适配者类和目标接口类进行适配，在对象适配器模式下通过组合方式实现，即：adapter类继承target类或者实现target接口，并在其内部包含一个adaptee对象的引用，通过对其内部的adaptee对象的调用实现客户端所需要的接口。
接下来以target为接口举例，对象适配器模式结构示意源代码如下：
target类包含client类所需要的与特定领域相关的接口。
public interface target {
// adaptee适配者有此方法的实现，但方法名可以不同
void specificoperation();
// adaptee适配者没有的其他方法
void otheroperation();
}adaptee 包含了 client 希望使用的某些业务方法，但 adaptee 不符合 client 的接口要求。
public class adaptee {
public void operation() {
system.out.println("执行adaptee的operation()方法...");
}
}adapter 实现 target 接口，并在其内部包含一个 adaptee 对象的引用，通过对其内部的 adaptee 对象的方法调用来实现客户端所需要的接口。
public class adapter implements target {
private adaptee adaptee;
public adapter(adaptee adaptee) {
super();
this.adaptee = adaptee;
}
@override
public void specificoperation() {
this.adaptee.operation();
}
@override
public void otheroperation() {
system.out.println("执行adapter的otheroperation()方法...");
}
}同样的，client 依旧要与一个 target 接口协同工作，对client进行简单修改。
public class client {
public static void clientoperation(target target){
target.specificoperation();
target.otheroperation();
}
public static void main(string[] args) {
adapter adapter = new adapter(new adaptee());
clientoperation(adapter);
}
}运行程序打印结果如下：
执行adaptee的operation()方法...
执行adapter的otheroperation()方法...接口适配器模式又被叫作缺省适配器(defaultadapter)模式，defaultadapter 为一个接口提供缺省实现，这样需实现该接口的类就可以直接从 defaultadapter 进行扩展，而不必再从原有接口进行扩展。当原接口中定义的方法很多，而其中大部分方法又不被需要时，这种模式非常实用。由缺省适配器类（由于该类一般都只为接口提供缺省的空实现，所以该类一般都被定义为抽象类）直接实现接口，并为所有方法提供缺省实现。这样，如果有用户类需要实现该接口就可以直接继承适配器类，并只需实现感兴趣的方法就可以了。
缺省适配器模式涉及的角色及其职责如下：
目标(target)接口类：用户类所需要实现的接口，定义有很多方法，但这些方法不一定全都被用户类所需要。
缺省适配器(defaultadapter)类：实现目标接口，并为所有接口方法提供缺省实现。
具体(concreteclass)用户类：用户类要实现某一个接口，但是又用不到接口所规定的所有的方法。
类适配器模式结构示意源代码如下：
target接口类是用户类所需要实现的接口，该接口定义有很多方法。
public interface target {
public void operation1();
public void operation2();
public void operation3();
public void operation4();
public void operation5();
public void operation6();
}defaultadapter类实现target接口，并为所有接口方法提供缺省实现。
public class defaultadapter implements target {
public void operation1() {
system.out.println("执行缺省适配器的operation1()方法...");
}
public void operation2() {
system.out.println("执行缺省适配器的operation2()方法...");
}
public void operation3() {
system.out.println("执行缺省适配器的operation3()方法...");
}
public void operation4() {
system.out.println("执行缺省适配器的operation4()方法...");
}
public void operation5() {
system.out.println("执行缺省适配器的operation5()方法...");
}
public void operation6() {
system.out.println("执行缺省适配器的operation6()方法...");
}
}接下来就要定义用户类了，我们定义两个具体用户类 concreteclassa 和 concreteclassb ，两个类都只实现 target 接口中的部分方法。
public class concreteclassa extends defaultadapter {
public void operation3() {
system.out.println("执行concreteclassa的operation3()方法...");
}
}public class concreteclassb extends defaultadapter {
public void operation4() {
system.out.println("执行concreteclassb的operation4()方法...");
}
public void operation5() {
system.out.println("执行concreteclassb的operation5()方法...");
}
}在很多情况下，用户类会需要实现某一个接口，但是又用不到接口所规定的所有的方法。通常的处理方法是，用户类要实现所有的方法，为那些有用的方法添加实现，为那些没有用的方法添加空的、平庸的实现。为不需要的方法添加空实现其实是一种浪费，有时也是一种混乱。除非看过这些方法的源代码或文档，程序员可能会以为这些方法不是空的。即便他知道其中有一些方法是空的，也不一定知道哪些方法是空的，哪些方法不是空的。缺省适配模式可以很好的处理这一情况。
从以上两个具体用户类 concreteclassa 和 concreteclassb的代码可以看出：两个用户类通过继承缺省适配器类，而无需再为接口中的全部方法添加实现。
应用场景：
sd内存卡是一种很常见的手机外置存储设备，我们可以通过给手机插入一个sd卡来扩展手机的存储空间， 当sd卡中存储的文件很多需要整理的时候问题来了，直接在手机上对sd卡中的文件进行整理(拷贝、删除、移动、修改等等)操作起来很不方便，于是我们想如果能够将sd卡插入电脑，然后通过电脑对sd卡上的文件进行整理该多方便。可不幸的是，大多数的电脑仅能连接具有usb接口的设备，显然，sd卡并不具备usb接口。
以上是适配器模式的一个典型应用场景，sd卡是专门为手机而设计的，在设计之初也并未想过要去把它插入电脑。现在我们想要把sd卡插入到电脑了，却发现sd卡因不具有usb插头而不能插入电脑。此时，再去重新设计和生产一种新型的具有usb接口的sd卡显然也并不合理。但是，很明显sd卡与u盘等usb接口设备都是存储设备，二者并无本质区别，理论上来说是完全可以插入电脑的。那么我们到底该怎么办呢？
以上问题的解决方法其实很简单：找一个usb接口的读卡器，将sd卡插入到读卡器，再将读卡器插入电脑，此时你会发现sd卡连上电脑了。
上例中的读卡器其实就是一个适配sd卡和usb接口的适配器，接下来我们用java代码来进行演示说明。
首先，为了使演示更加清晰，我们重新定义一个file类，用来表示sd卡中存储的文件。
public class file {
//文件名
private string filename;
//文件大小
private double filesize;
//构造方法中指定文件名和文件大小
public file(string filename, double filesize) {
super();
this.filename = filename;
this.filesize = filesize;
}
public string getfilename() {
return filename;
}
public double getfilesize() {
return filesize;
}
}我们的sd卡类提供了基本的文件添加、文件删除、显示已存储文件的功能，其完整代码如下。
import java.util.hashmap;
import java.util.map;
import java.util.map.entry;
public class sdcard {
// sd卡的存储空间总大小
private double volume;
// sd卡的可用存储空间大小
private double vacantvolume;
// 将sd卡中存储的文件保存到一个map里面
private map filemap = new hashmap();
public sdcard(double volume) {
super();
this.volume = volume;
this.vacantvolume = volume;
}
public double getvacantvolume() {
return vacantvolume;
}
public void setvacantvolume(double vacantvolume) {
this.vacantvolume = vacantvolume;
}
public double getvolume() {
return volume;
}
public map getfilemap() {
return filemap;
}
public void addfile(file file) {
file tempfile = this.filemap.get(file.getfilename());
if (null != tempfile) {
system.out.println("文件《" file.getfilename() "》已存在，添加失败...");
} else {
if (this.vacantvolume > file.getfilesize()) {
this.filemap.put(file.getfilename(), file);
this.vacantvolume = this.vacantvolume - file.getfilesize();
system.out.println("添加文件《" file.getfilename() "》成功...");
} else {
system.out.println("剩余存储空间不足，文件《" file.getfilename()
"》添加失败...");
}
}
}
public void deletefile(string filename) {
file tempfile = this.filemap.get(filename);
if (null == tempfile) {
system.out.println("文件《" filename "》不存在，删除失败...");
} else {
this.filemap.remove(filename);
this.vacantvolume = this.vacantvolume tempfile.getfilesize();
system.out.println("删除文件《" filename "》成功...");
}
}
public void listfiles() {
if (filemap.size() > 0) {
system.out.println();
system.out
.println("*********************文件列表*********************");
int i = 1;
for (entry entry : filemap.entryset()) {
system.out.println(i ". 文件名：《"
entry.getvalue().getfilename() "》，文件大小："
entry.getvalue().getfilesize() "兆。");
i ;
}
system.out.println();
}
}
} 接下来定义一个usb存储设备的接口类 usbdevice，其声明的方法如下。
import java.util.list;
public interface usbdevice {
//返回usb存储设备的总容量
public double getusbvolume();
//返回usb存储设备的剩余可用空间
public double getusbvacantvolume();
//列出usb存储设备中的文件信息
public void listusbfiles();
//添加文件到usb存储设备
public void addtousb(file file);
//从usb存储设备删除单个文件
public void deletefromusb(string filename);
//从usb存储设备批量删除文件
public void deletefromusb(list filenames);
} 接下来该定义我们的适配器类了，该类名为 cardreader (读卡器),它通过调用sd卡类中的方法实现了在 usbdevice 中声明的接口方法，代码如下。
import java.util.list;
public class cardreader implements usbdevice{
private sdcard sdcard;
public cardreader(sdcard sdcard) {
super();
this.sdcard = sdcard;
}
@override
public double getusbvolume() {
return this.sdcard.getvolume();
}
@override
public double getusbvacantvolume() {
return this.sdcard.getvacantvolume();
}
@override
public void listusbfiles() {
this.sdcard.listfiles();
}
@override
public void addtousb(file file) {
this.sdcard.addfile(file);
}
@override
public void deletefromusb(string filename) {
this.sdcard.deletefile(filename);
}
@override
public void deletefromusb(list filenames) {
if(null!=filenames && filenames.size()>0){
for(string filename:filenames){
this.sdcard.deletefile(filename);
}
}
}
} 最后定义电脑 computer 类，该类仅支持插入具有usb接口的设备(即实现了 usbdevice 接口的对象)，我们在此为其添加了一个 usbdevice 的内部属性代表连接到电脑的usb设备，在 computer 类中创建一个main方法进行测试。
import java.util.arraylist;
public class computer {
private usbdevice usbdevice;
private usbdevice getusbdevice() {
return usbdevice;
}
private void setusbdevice(usbdevice usbdevice) {
this.usbdevice = usbdevice;
}
public static void main(string[] args) {
// 新建一个大小为1024m的sd卡
sdcard sdcard = new sdcard(1024d);
// 在sd卡中存入两个文件
sdcard.addfile(new file("java从入门到放弃.pdf", 10d));
sdcard.addfile(new file("不良人之灵主.avi", 68d));
// 拷入重复文件测试
sdcard.addfile(new file("不良人之灵主.avi", 68d));
// 列出sd卡中文件信息
sdcard.listfiles();
// 接下来将sd卡插入到读卡器
cardreader cardreader = new cardreader(sdcard);
computer computer = new computer();
// 再将读卡器插入电脑
computer.setusbdevice(cardreader);
computer.getusbdevice().addtousb(new file("唐伯虎点秋香.rmvb", 600d));
computer.getusbdevice().addtousb(new file("c 基础算法.txt", 0.01d));
computer.getusbdevice().addtousb(new file("冰河世纪4.rmvb", 888d));
computer.getusbdevice().listusbfiles();
computer.getusbdevice().deletefromusb("java从入门到放弃.pdf");
computer.getusbdevice().listusbfiles();
computer.getusbdevice().deletefromusb(new arraylist() {
{
add("java从入门到放弃.pdf");
add("不良人之灵主.avi");
}
});
computer.getusbdevice().listusbfiles();
}
} 运行程序结果打印如下：
添加文件《java从入门到放弃.pdf》成功...
添加文件《不良人之灵主.avi》成功...
文件《不良人之灵主.avi》已存在，添加失败...
*********************文件列表*********************
1. 文件名：《java从入门到放弃.pdf》，文件大小：10.0兆。
2. 文件名：《不良人之灵主.avi》，文件大小：68.0兆。
添加文件《唐伯虎点秋香.rmvb》成功...
添加文件《c 基础算法.txt》成功...
剩余存储空间不足，文件《冰河世纪4.rmvb》添加失败...
*********************文件列表*********************
1. 文件名：《唐伯虎点秋香.rmvb》，文件大小：600.0兆。
2. 文件名：《java从入门到放弃.pdf》，文件大小：10.0兆。
3. 文件名：《c 基础算法.txt》，文件大小：0.01兆。
4. 文件名：《不良人之灵主.avi》，文件大小：68.0兆。
删除文件《java从入门到放弃.pdf》成功...
*********************文件列表*********************
1. 文件名：《唐伯虎点秋香.rmvb》，文件大小：600.0兆。
2. 文件名：《c 基础算法.txt》，文件大小：0.01兆。
3. 文件名：《不良人之灵主.avi》，文件大小：68.0兆。
文件《java从入门到放弃.pdf》不存在，删除失败...
删除文件《不良人之灵主.avi》成功...
*********************文件列表*********************
1. 文件名：《唐伯虎点秋香.rmvb》，文件大小：600.0兆。
2. 文件名：《c 基础算法.txt》，文件大小：0.01兆。通过使用适配器模式，我们可以达到以下目的：
1 复用现有的类，解决现有类和复用环境要求不一致的问题。
2 将目标类和适配者类解耦，通过引入一个适配器类重用现有的适配者类，而无需修改原有代码。
3 一个对象适配器可以把适配者类和它的子类都适配到目标接口。
类适配器模式和对象适配器模式比较：
-类适配器通过继承方式来实现，是静态的；而对象适配器通过组合方式来实现，是动态的。
-对于类适配器，适配器直接继承自 adaptee ，这使得适配器不能和 adaptee 的子类一起工作。
-对于对象适配器，同一个适配器可以把 adaptee 和它的子类都适配到目标接口。
-对于类适配器，适配器可以重定义 adaptee 的部分行为，相当于子类覆盖父类的部分实现方法。
-对于对象适配器，要重定义 adaptee 的行为比较困难，这种情况下，需要定义 adaptee 的子类来实现重定义，然后让适配器组合子类。