适配器模式（Adapter模式）详解

模式的定义

适配器模式（Adapter）将一个类的接口转换成客户希望的另外一个接口。Adapter 模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

适配器模式分为类适配器模式和对象适配器模式两种，前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少些。

模式的结构与实现

类适配器模式采用多重继承对一个接口与另外一个接口进行匹配，Java 不支持多继承，但可以定义一个适配器类来实现当前系统的业务接口，同时又继承现有组件库中已经存在的组件。

对象适配器模式可釆用将现有组件库中已经实现的组件引入适配器类中，该类同时实现当前系统的业务接口。

现在来介绍它们的基本结构。

1. 模式的结构与特点

适配器模式（Adapter）包含以下主要角色。

• 目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口。
• 适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口。
• 适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。

优点：

• 客户端通过适配器可以透明地调用目标接口。
• 复用了现存的类，程序员不需要修改原有代码而重用现有的适配者类。
• 将目标类和适配者类解耦，解决了目标类和适配者类接口不一致的问题。
• 在很多业务场景中符合开闭原则。

缺点：

• 适配器编写过程需要结合业务场景全面考虑，可能会增加系统的复杂性。
• 增加代码阅读难度，降低代码可读性，过多使用适配器会使系统代码变得凌乱

类适配器模式的结构图：

类适配器模式的结构图

对象适配器模式的结构图：

对象适配器模式的结构图

2. 模式的实现

类适配器模式的代码如下：

/**
 * 这是客户所期待的接口，目标可以是具体的或抽象类，也可以是接口
 */
public interface Target {
    void request();
}

/**
 * 需要适配的类，被访问和适配的现存组件库中的组件接口
 */
public class Adaptee {
    public void specificRequest(){
        System.out.println("适配者中的业务代码被调用！");
    }
}

/**
 * 类适配器类
 */
public class ClassAdapter extends Adaptee implements Target{
    @Override
    public void request() {
        specificRequest();
    }
}

//客户端代码
public class ClassAdapterTest
{
    public static void main(String[] args)
    {
        System.out.println("类适配器模式测试：");
        Target target = new ClassAdapter();
        target.request();
    }
}

运行结果如下：

类适配器模式测试：
适配者中的业务代码被调用！

对象适配器模式的代码如下：

/**
 * 对象适配器，通过在内部包装一个 Adaptee 对象，把源接口转换为目标接口
 */
public class ObjectAdapter implements Target {

    // 建立一个私有的 Adaptee 对象
    private Adaptee adaptee;

    public ObjectAdapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        // 把表面上调用 request() 方法变成实际调用 specificRequest() 
        adaptee.specificRequest();
    }
}

//客户端代码
public class ObjectAdapterTest
{
    public static void main(String[] args)
    {
        System.out.println("对象适配器模式测试：");
        // 对客户端来说，调用的就是 Target 的 request()
        Target target = new ObjectAdapter();
        target.request();
    }
}

运行结果如下：

类适配器模式测试：
适配者中的业务代码被调用！

适配器模式使用场景

• 系统需要使用现有的类，而此类的接口不符合系统的需要，即接口不兼容。
• 想建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作。
• 需要一个统一的输出接口，而输入端的类型不可预知。

模式的应用实例

用适配器模式（Adapter）模拟火箭队比赛，教练暂停时给后卫、中锋、前锋分配进攻和防守的方法。

适配器结构图

后卫、中锋、前锋都是球员，所有应该有个球员抽象类，有进攻和防守的方法。

/**
 * 抽象球员类
 */
public abstract class Player {

    /**
     * 球员名字
     */
    protected String name;

    public Player(String name) {
        this.name = name;
    }

    /**
     * 进攻方法
     */
    public abstract void attack();

    /**
     * 防守方法
     */
    public abstract void defense();
}


/**
 * 前锋
 */
public class Forwards extends Player {

    public Forwards(String name) {
        super(name);
    }

    @Override
    public void attack() {
        System.out.println("前锋「0」进攻  " + name);
    }

    @Override
    public void defense() {
        System.out.println("前锋「0」防守  " + name);
    }
}

/**
 * 中锋
 */
public class Center extends Player {

    public Center(String name) {
        super(name);
    }

    @Override
    public void attack() {
        System.out.println("中锋「0」进攻  " + name);
    }

    @Override
    public void defense() {
        System.out.println("中锋「0」防守  " + name);
    }
}

/**
 * 后卫
 */
public class Guards extends Player {

    public Guards(String name) {
        super(name);
    }

    @Override
    public void attack() {
        System.out.println("后卫「0」进攻  " + name);
    }

    @Override
    public void defense() {
        System.out.println("后卫「0」防守  " + name);
    }
}

/**
 * 外籍中锋
 */
public class ForeignCenter {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void attackForeign() {
        System.out.println("外籍中锋「0」进攻  " + name);
    }

    public void defenseForeign() {
        System.out.println("外籍中锋「0」防守  " + name);
    }
}


/**
 * 翻译者
 */
public class Translator extends Player {
    // 申明并实例化一个内部"外籍中锋"对象，表明翻译者与外籍球员有关联
    private ForeignCenter foreignCenter = new ForeignCenter();

    public Translator(String name) {
        super(name);
    }

    /**
     * 翻译者将"attack"翻译为"进攻"告诉外籍中锋
     */
    @Override
    public void attack() {
        foreignCenter.attackForeign();
    }

    /**
     * 翻译者将"defense"翻译为"防守"告诉外籍中锋
     */
    @Override
    public void defense() {
        foreignCenter.defenseForeign();
    }
}


public class PlayerTest {
    public static void main(String[] args) {
        Player forwards = new Forwards("巴蒂尔");
        forwards.attack();

        Player center = new Center("科比");
        center.attack();

        Player guards = new Guards("詹姆斯");
        guards.attack();

        // 翻译者
        Translator translator = new Translator("姚明");
        translator.attack();
        translator.defense();
    }
}

运行结果：

前锋「0」进攻  巴蒂尔
中锋「0」进攻  科比
后卫「0」进攻  詹姆斯
外籍中锋「0」进攻  姚明
外籍中锋「0」防守  姚明