1. 意图（Intent）

把一个类接口转换成另一个用户需要的接口。

使得原本由于接口不兼容而不能一起工作的那些类可以一起工作

image.png
适配器模式做的就是，有一个接口需要实现，但是我们现成的对象都不满足，需要加一层适配器来进行适配。

适配器模式总体来说分三种：默认适配器模式、对象适配器模式、类适配器模式。先不急着分清楚这几个，先看看实现例子再说。

2. 类图（Class Diagram）

image.png

3. 实现（Implementation）

默认适配器模式

首先，我们先看看最简单的适配器模式默认适配器模式(Default Adapter)是怎么样的。

我们用 Appache commons-io 包中的 FileAlterationListener 做例子，此接口定义了很多的方法，用于对文件或文件夹进行监控，一旦发生了对应的操作，就会触发相应的方法。

  1. public interface FileAlterationListener {
  2.     void onStart(final FileAlterationObserver observer);
  3.     void onDirectoryCreate(final File directory);
  4.     void onDirectoryChange(final File directory);
  5.     void onDirectoryDelete(final File directory);
  6.     void onFileCreate(final File file);
  7.     void onFileChange(final File file);
  8.     void onFileDelete(final File file);
  9.     void onStop(final FileAlterationObserver observer);
  10. }

此接口的一大问题是抽象方法太多了，如果我们要用这个接口，意味着我们要实现每一个抽象方法，如果我们只是想要监控文件夹中的文件创建和文件删除事件，可是我们还是不得不实现所有的方法，很明显，这不是我们想要的。

所以，我们需要下面的一个适配器，它用于实现上面的接口，但是所有的方法都是空方法，这样，我们就可以转而定义自己的类来继承下面这个类即可。

public class FileAlterationListenerAdaptor implements FileAlterationListener {

    public void onStart(final FileAlterationObserver observer) {
    }

    public void onDirectoryCreate(final File directory) {
    }

    public void onDirectoryChange(final File directory) {
    }

    public void onDirectoryDelete(final File directory) {
    }

    public void onFileCreate(final File file) {
    }

    public void onFileChange(final File file) {
    }

    public void onFileDelete(final File file) {
    }

    public void onStop(final FileAlterationObserver observer) {
    }
}

比如我们可以定义以下类，我们仅仅需要实现我们想实现的方法就可以了：

public class FileMonitor extends FileAlterationListenerAdaptor {
    public void onFileCreate(final File file) {
        // 文件创建
        doSomething();
    }

    public void onFileDelete(final File file) {
        // 文件删除
        doSomething();
    }
}

当然，上面说的只是适配器模式的其中一种，也是最简单的一种，无需多言。

对象适配器模式

下面，介绍“正统的”适配器模式。来看一个《Head First 设计模式》中的一个例子，我稍微修改了一下，看看怎么将鸡适配成鸭，这样鸡也能当鸭来用。因为，现在鸭这个接口，我们没有合适的实现类可以用，所以需要适配器。

鸭类

public interface Duck {
    public void quack(); // 鸭的呱呱叫
    public void fly();   // 飞
}

鸡类

public interface Cock {
    public void gobble(); // 鸡的咕咕叫
    public void fly();    // 飞
}

野鸡类：实现鸡的接口，作为适配器的初始化参数

public class WildCock implements Cock {
    public void gobble() {
        System.out.println("咕咕叫");
    }
    public void fly() {
        System.out.println("鸡也会飞哦");
    }
}

鸭接口有 fly() 和 quack() 两个方法，鸡 Cock 如果要冒充鸭，fly() 方法是现成的，但是鸡不会鸭的呱呱叫，没有 quack() 方法。这个时候就需要适配了：

// 毫无疑问，首先，这个适配器肯定需要 implements Duck，这样才能当做鸭来用
public class CockAdapter implements Duck {
    // 传参进来的是【野鸡类对象】
    Cock cock;

    // 构造方法中需要一个鸡的实例，此类就是将这只鸡适配成鸭来用
      public CockAdapter(Cock cock) {
        this.cock = cock;
    }

    // 实现鸭的呱呱叫方法
    @Override
      public void quack() {
        // 内部其实是一只鸡的咕咕叫
        cock.gobble();
    }

      @Override
      public void fly() {
        cock.fly();
    }
}

客户端调用很简单了：

public class Client {
    public static void main(String[] args) {
          // 有一只野鸡
          Cock wildCock = new WildCock();
          // 成功将野鸡适配成鸭
          Duck duck = new CockAdapter(wildCock);
          ...
    }
}

到这里，大家也就知道了适配器模式是怎么回事了。无非是我们需要一只鸭，但是我们只有一只鸡，这个时候就需要定义一个适配器，由这个适配器来充当鸭，但是适配器里面的方法还是由鸡来实现的。
我们用一个图来简单说明下：
image.png
上图应该还是很容易理解的，我就不做更多的解释了。下面，我们看看类适配模式怎么样的。

类适配器模式

废话少说，直接上图：
image.png
看到这个图，大家应该很容易理解的吧，通过继承的方法，适配器自动获得了所需要的大部分方法。这个时候，客户端使用更加简单，直接 Target t = new SomeAdapter(); 就可以了。

//首先，这个适配器需要继承WildCock获得鸡的实现方法,然后implements Duck，这才能当做鸭来用
public class CockAdapter extends WildCock implements Duck {

    // 实现鸭的呱呱叫方法
    @Override
      public void quack() {
        // 内部其实是父类野鸡的咕咕叫
        super.gobble();
    }

      @Override
      public void fly() {
        super.fly();
    }
}

客户端调用：

public class Client {
    public static void main(String[] args) {
        // 成功将野鸡适配成鸭
          Duck duck = new CockAdapter();
          ...
    }
}

适配器模式总结

  • 类适配和对象适配的异同

    一个采用继承，一个采用组合；类适配属于静态实现，对象适配属于组合的动态实现，对象适配需要多实例化一个对象。总体来说，对象适配用得比较多。

  • 适配器模式和代理模式的异同

比较这两种模式，其实是比较对象适配器模式和代理模式，在代码结构上，它们很相似，都需要一个具体的实现类的实例。但是它们的目的不一样，代理模式做的是增强原方法的活；适配器做的是适配的活，为的是提供“把鸡包装成鸭，然后当做鸭来使用”，而鸡和鸭它们之间原本没有继承关系。

adapter-5.png

4. JDK