设计模式简述（十三）适配器模式

描述

适配器模式常用于系统已经上限稳定运行，但现有需求需要将两个不匹配的类放到一起工作时使用。

也就是说这是一个迭代阶段使用的模式。
这种模式，正应了那句软件领域的名言：没有什么是加一层解决不了的

基本使用

要实现适配器模式，原有系统类需存在抽象层，否则无从谈起

• 定义原有抽象层（可以是抽象类、接口）

public abstract class AbstractService {
    abstract void execute();
}

• 定义原有业务类

public class DefaultService extends AbstractService {
    @Override
    void execute() {
        System.out.println("DefaultService.....");
    }
}

• 外来不兼容类

public class Adaptee {
    public void action() {
        System.out.println("外来的不兼容对象....");
    }
}

• 适配器

public class Adapter extends AbstractService {
    private Adaptee adaptee;

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

    @Override
    void execute() {
        adaptee.action();
    }
}

使用

public class Sample {
    public static void main(String[] args) {
        Sample sample = new Sample();
        // 原有兼容类的调用
        sample.function(new DefaultService());
        
        System.out.println("========== 不兼容类的调用 ======");

        // 外来不兼容对象
        Adaptee adaptee = new Adaptee();
        // 适配器对象
        AbstractService service = new Adapter(adaptee);
        // 将适配器对象传入方法
        sample.function(service);
    }

    /**
     * 原本的方法只接收 AbstractService 类型参数
     * 如果直接将Adaptee传入是不行的，因此我们加了一层中间层 Adapter
     * @param service
     */
    private void function(AbstractService service) {
        service.execute();
    }
}

关于适配器关联不兼容类的方式

如果原有抽象层是抽象类

也就是适配器只能通过继承的方式实现原有逻辑时，不兼容类只能通过成员的方式关联到适配器中
也就是上面的方式

public class Adapter extends AbstractService {
    private Adaptee adaptee;

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

    @Override
    void execute() {
        adaptee.action();
    }
}

若原有抽象是接口

那么不兼容类除了成员的方式关联外。适配器还可以继承不兼容的类

• 定义原有抽象层

public interface IService {
    void execute();
}

• 定义适配器

public class Adapter extends Adaptee implements IService {
    @Override
    public void execute() {
        action();
    }
}

使用

在得到不兼容对象后，先将其转为适配器对象，再将其传入原有接口

public class Sample {
    public static void main(String[] args) {
        Sample sample = new Sample();
        // 原有兼容类的调用
        sample.function(new DefaultService());
        System.out.println("========== 不兼容类的调用 ======");

        Adaptee adaptee = new Adaptee();
        // 自定义方式将 adaptee 转换成 Adapter
        Adapter adapter = sample.convert(adaptee);
        // 将适配器对象传入方法
        sample.function(adapter);
    }

    private Adapter convert(Adaptee adaptee) {
    // 自定义转换方法
        return new Adapter();
    }

    /**
     * 原本的方法只接收 AbstractService 类型参数
     * 如果直接将Adaptee传入是不行的，因此我们加了一层中间层 Adapter
     * @param service
     */
    private void function(IService service) {
        service.execute();
    }
}