</pre>定义：适配器模式将一个类的接口（源）转换成客户期望的另外一个目标接口，使得原本由于接口不兼容而不能一起工作的哪些类可以在一起工作。<span ></span>适配器。适配就是由“源”到“目标”的适配，而当中链接两者的关系就是适配器。它负责把“源”过度到“目标”。接着讨论如何加说法语这个方法，也许你会说，为什么不直接在“源”中直接添加方法我的理解是，适配是为了实现某种目的而为一个源类暂时性的加上某种方法，所以不能破坏原类的结构。同时不这么做也符合Java的高内聚，低耦合的原理。既然不能直接加，接着我们就来说该怎么来实现为人这个“源”添加一个方法，而又不破坏“源”的本身结构。适配器模式有2种，第一种是“面向类的适配器模式”，（类适配器采用继承方式）第二种是“面向对象的适配器模式”。（对象适配器采用组合方式）把被适配者，作为一个对象组合到适配器类中，以实现目标接口的添加功能。适配器作用1，透明：通过适配器，客户端可以调用同一个接口，因而对客户来说是透明的，这样做更简单，更直接，更紧凑2，重用：复用了现存的类，解决现存类和复用环境要求不一致的问题。3，低耦合：将目标类和适配者类解耦，通过引入一个适配器类重用现有的适配者类，而无需修改原有代码（遵循开闭原则）4，灵活性和扩展性都非常好，符合开闭原则<p></p><p></p>举个我们生活中常见的例子。第一个例子：我们有时候外出旅游，由于我们的电脑电源插头是三相插头，电源只是二相插头，我们如果想给电脑充电，就需要把二相插头转换成三相插头，这时我们就需要一个转换器，而这个转换器就是我们需要的适配器。实现这一需求的过程中我们需要4部分构成。1，客户端笔记本电脑充电。（NoteBook）2，目标接口（三相插头接口）ThreePluginterface3，适配器 二相转化成三相 TwoChangeThree4，被适配类 二相电流（TwoPlug）<div><p>代码如下</p><div></div>一：使用对象适配器1，客户端笔记本电脑充电。（NoteBook）</div><div><pre name="code" class="java">package 适配器设计模式;
//客户端笔记本电脑
public class NoteBook {
//传入三相插座
private ThreePlugInterface plug;
//定义一个构造函数
public NoteBook(ThreePlugInterface plug){
this.plug=plug;
}
//定义满足需求的充电动作(使用三相插座充电)
public void charge(){
plug.powerWithThree();
}
public static void main(String[] args) {
//现在只有二相插座
TwoPlug two=new TwoPlug();
//声明一个用来使用的三相插座参数。但是我们只有二相插座，这时就需要使用适配器来把二相转化成三相。
ThreePlugInterface three=new TwoChangeThreeAdapter(two);
NoteBook NB=new NoteBook(three);
NB.charge();
System.out.println("-------------");
three =new TwoChangeThreeAdapter2();
NB=new NoteBook(three);
NB.charge();
}
}2，目标接口（三相插头接口）ThreePluginterface
package 适配器设计模式;
/*
* 目标接口：三相插座接口。
*/
public interface ThreePlugInterface {
//使用三相电流供电。
public void powerWithThree();
}3，适配器 二相转化成三相 TwoChangeThree
package 适配器设计模式;
/*
* 定义一个二相转化成三相的插座适配器。
*
* 对象适配器：
* 把被适配者（二相插座类）作为一个对象组合到适配器类中，用以给目标接口添加功能。
*/
public class TwoChangeThreeAdapter implements ThreePlugInterface {
//声明一个二相插座作为成员变量。把其功能组合到三相插座类中。
private TwoPlug plug;
//声明一个构造函数
public TwoChangeThreeAdapter(TwoPlug plug) {
this.plug=plug;
}
public void powerWithThree(){
//使用二相插座给三相插座供电，既把二相插座的功能添加给三相插座。
System.out.println("使用二相插座给三相插座供电(目标接口供电)");
plug.powerWithTwo();
}
}4，被适配类 二相电流（TwoPlug）
package 适配器设计模式;
/*
* 被适配类：二相插座
*/
public class TwoPlug {
//使用二相插座供电
public void powerWithTwo(){
System.out.println("使用二相电流给三相插座供电（被适配类）");
}
}二：使用类适配器
1，客户端笔记本电脑充电。（NoteBook）
和对象适配器一样的代码
2，目标接口（三相插头接口）ThreePluginterface
和对象适配器一样的代码
3，适配器 二相转化成三相 TwoChangeThree
package 适配器设计模式;
/*
* 采用继承方式的插座适配器。
*/
public class TwoChangeThreeAdapter2 extends TwoPlug implements ThreePlugInterface {
public void powerWithThree() {
this.powerWithTwo();//继承被适配类的充电方法。
System.out.println("（继承方式的适配器）使用二相电流给三相插座供电（被适配类）");
}
}4，被适配类 二相电流（TwoPlug）
和对象适配器一样的代码
第二个例子：
举个简单的例子，比如有一个“源”是一个对象人，他拥有2种技能分别是说日语和说英语
而某个岗位（目标）需要你同时回说日语、英语、和法语，
好了，现在我们的任务就是要将人这个“源”适配的这个岗位中，如何适配呢？
显而易见地我们需要为人添加一个说法语的方法，这样才能满足目标的需要。
先说“面向类的适配器模式”。顾名思义，这类适配器模式就是主要用于，单一的为某个类而实现适配的这样一种模式，为什么说只为某个类去实现，一会提到，我们先展示这种类适配模式的代码实现。
源的代码如下：
public class Person {
private String name;
private String sex;
private int age;
public void speakJapanese(){
System.out.println("I can speak Japanese!");
}
public void speakEnglish(){
System.out.println("I can speak English!");
}
...//以下省略成员变量的get和set方法
}
目标接口的代码如下：
public interface Job {
public abstract void speakJapanese();
public abstract void speakEnglish();
public abstract void speakFrench();
}
适配器的代码如下：
public class Adapter extends Person implements Job{
public void speakFrench() {
}
}
好了，代码看完然后要做一些说明了，之前遗留的一个问题，为什么称其为类适配模式呢？
很显然的，Adapter类继承了Person类，而在Java这种单继承的语言中也就意味着，
他不可能再去继承其他的类了，这样也就是这个适配器只为Person这一个类服务。所以称其为类适配模式。
说完类的适配模式，我们要开始说第2种对象的适配器模式了。
对象适配器模式是把“源”作为一个对象聚合到适配器类中。同样的话不多说，贴上代码：
源的代码以及目标代码同上，再次不再赘述。
仅贴出适配器代码：
public class Adapter implements Job {
Person person;
public Adapter(Person person) {
this.person = person;
}
public void speakEnglish() {
person.speakEnglish();
}
public void speakJapanese() {
person.speakJapanese();
}
//new add
public void speakFrench() {
}
}
对象的适配器模式，把“源”作为一个构造参数传入适配器，然后执行接口所要求的方法
这种适配模式可以为多个源进行适配。弥补了类适配模式的不足。
现在来对2种适配模式做个分析：
1.类的适配模式用于单一源的适配，由于它的源的单一话，代码实现不用写选择逻辑，很清晰；
而对象的适配模式则可用于多源的适配，弥补了类适配模式的不足，使得原本用类适配模式需要写很多适配器的情况不复存在，
弱点是，由于源的数目可以较多，所以具体的实现条件选择分支比较多，不太清晰。
2.适配器模式主要用于几种情况：
（1）系统需要使用现有的类，但现有的类不完全符合需要。
（2）讲彼此没有太大关联的类引进来一起完成某项工作（指对象适配）。
最后，再来顺带谈谈默认适配器模式：这种模式的核心归结如下：当你想实现一个接口但又不想实现所有接口方法，只想去实现一部分方法时，就用中默认的适配器模式，他的方法是在接口和具体实现类中添加一个抽象类，而用抽象类去空实现目标接口的所有方法。而具体的实现类只需要覆盖其需要完成的方法即可。代码如下：
接口类：
public interface Job {
public abstract void speakJapanese();
public abstract void speakEnglish();
public abstract void speakFrench();
public abstract void speakChinese();
}
抽象类：
public abstract class JobDefault implements Job{
public void speakChinese() {
}
public void speakEnglish() {
}
public void speakFrench() {
}
public void speakJapanese() {
}
}
实现类：
public class JobImpl extends JobDefault{
public void speakChinese(){
System.out.println("I can speak Chinese!");
}
}
好了，适配器模式就先说到这了，希望对自己和大家都有一个提高。
代码如下
