适配器模式属于七种结构性模式（适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式）之一：

适配器模式又分三种：类的适配器模式、对象的适配器模式、接口的适配器模式。

 适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。

先看类的适配器模式：

核心思想就是：有一个Source类，拥有一个方法，待适配，目标接口时Targetable，通过Adapter类，将Source的功能扩展到Targetable里，看代码：

public class Source {        public void method1() {          System.out.println("this is original method!");      }  }

public interface Targetable {                /* 与原类中的方法相同 */          public void method1();                /* 新类的方法 */          public void method2();      }

public class Adapter extends Source implements Targetable {                @Override          public void method2() {              System.out.println("this is the targetable method!");          }      }

下面是测试类：

public class AdapterTest {                public static void main(String[] args) {              Targetable target = new Adapter();              target.method1();              target.method2();          }      }

输出：

this is original method!this is the targetable method!

这样Targetable接口的实现类就具有了Source类的功能。

对象的适配器模式

基本思路和类的适配器模式相同，只是将Adapter类作修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。看图：

public class Wrapper implements Targetable {                private Source source;                    public Wrapper(Source source){              super();              this.source = source;          }          @Override          public void method2() {              System.out.println("this is the targetable method!");          }                @Override          public void method1() {              source.method1();          }      }

测试类：

public class AdapterTest {                public static void main(String[] args) {              Source source = new Source();              Targetable target = new Wrapper(source);              target.method1();              target.method2();          }      }

接口的适配器模式:

有时候我们写的接口里面有多个抽象方法，我们写实现类的时候，必须全部实现这些抽象方法，有时候没有必要，可以借助抽象类来解决，

这个抽象类实现该接口，我们一个实体类继承该抽象类就不用重写全部的接口里的方法了。

public interface Sourceable {                    public void method1();          public void method2();      }

public abstract class Wrapper2 implements Sourceable{                    public void method1(){}          public void method2(){}      }

public class SourceSub1 extends Wrapper2 {          public void method1(){              System.out.println("the sourceable interface's first Sub1!");          }      }

public class SourceSub2 extends Wrapper2 {          public void method2(){              System.out.println("the sourceable interface's second Sub2!");          }      }

public class WrapperTest {                public static void main(String[] args) {              Sourceable source1 = new SourceSub1();              Sourceable source2 = new SourceSub2();                            source1.method1();              source1.method2();              source2.method1();              source2.method2();          }      }

输出：

the sourceable interface's first Sub1!the sourceable interface's second Sub2!