设计模式结构型模式之适配器模式

一、概述和使用场景

1、概述

适配器模式是一种结构型设计模式，它允许不兼容的接口之间进行适配，使得原本无法一起工作的类可以协同工作。适配器模式通过引入一个适配器类，将一个类的接口转换成客户端所期待的接口，从而使原本由于接口不兼容而不能一起工作的两个类能够协同工作。

2、使用场景：

1. 当需要将一个类的接口转换成客户端所期待的另一个接口时，可以使用适配器模式。例如，如果一个类库中的某个接口与你的代码中所需的接口不一致，可以创建一个适配器类来将两者之间进行适配。
2. 当需要复用一些已经存在的类，但是它们的接口与你的代码所需的不兼容时，可以使用适配器模式。通过创建适配器类，可以将已有的类的接口转换成你所需要的接口。
3. 当需要通过适配器让多个类协同工作时，可以使用适配器模式。通过引入适配器类，可以统一多个类的接口，使它们可以协同工作。

3、主要分类

类适配器模式、接口适配器模式、对象适配器模式

二、 代码示例

下面是一个简单的Java代码示例，展示了适配器模式的使用：

1、类适配器模式

定义一个被适配的对象（将被改造的对象） ApplePhone

package org.storemanage.regestercenter.adaptormode;

/**
 * @CreateTime: 2024-08-29
 * @Description: 苹果手机（被适配的对象）
 * @Version: 1.0
 * @Author: hkf
 */

public class ApplePhone {

    private String name ;

    public void usbCable(){
        System.out.println("苹果充电器！！");
    }
}

安卓手机将要被改造的对象 AndroidPhone

package org.storemanage.regestercenter.adaptormode;

/**
 * @CreateTime: 2024-08-29
 * @Description: 安卓手机（适配的对象）
 * @Version: 1.0
 * @Author: hkf
 */

public interface AndroidPhone {


    //充电
    void usbCable();
}

创建一个适配器类 PhoneAdaptor ，将苹果手机的充电器改为能被安卓手机使用的充电器

package org.storemanage.regestercenter.adaptormode;

/**
 * @CreateTime: 2024-08-29
 * @Description: 手机转换适配器
 * @Version: 1.0
 * @Author: hkf
 */
public class PhoneAdaptor extends ApplePhone  implements  AndroidPhone   {
    @Override
    public void usbCable() {
        System.out.println(" 买个数据转换器 现在是安卓手机充电器！！");
    }
}

创建一个安卓手机对象

package org.storemanage.regestercenter.adaptormode;

/**
 * @CreateTime: 2024-08-29
 * @Description: 安卓手机对象，方便调用
 * @Version: 1.0
 * @Author: hkf
 */

public class Phone {

    //定义一个安卓手机的使用
    public void AndroidUsb(AndroidPhone androidPhone) {
        androidPhone.usbCable();
    }
}

用户 UserClient 用转换过后的苹果充电线充电（现在是适用安卓的充电线）

package org.storemanage.regestercenter.adaptormode;

/**
 * @CreateTime: 2024-08-29
 * @Description: 用户
 * @Version: 1.0
 * @Author: hkf
 */
public class UserClient {
    public static void main(String[] args) {
        //证明目前这个苹果充电器已经转换为安卓充电器
        Phone phone = new Phone();
        phone.AndroidUsb(new PhoneAdaptor());
    }
}

2、接口适配器

下面是一个简单示例的Java代码，展示了如何实现接口适配器模式：

// 目标接口
interface TargetInterface {
    void method1();
    void method2();
    void method3();
}

// 接口适配器类
abstract class InterfaceAdapter implements TargetInterface {
    @Override
    public void method1() {
        // 默认实现
    }

    @Override
    public void method2() {
        // 默认实现
    }

    @Override
    public void method3() {
        // 默认实现
    }
}

// 具体适配器类
class ConcreteAdapter extends InterfaceAdapter {
    @Override
    public void method2() {
        // 重写method2
        // 实现适配的逻辑
    }
}

// 测试代码
public class AdapterExample {
    public static void main(String[] args) {
        // 创建具体适配器对象
        TargetInterface adapter = new ConcreteAdapter();

        // 调用目标接口方法
        adapter.method1();
        adapter.method2(); // 已经在适配器中实现了适配的逻辑
        adapter.method3();
    }
}

在这个示例中，有一个目标接口 TargetInterface，其中定义了三个方法 method1()、method2() 和 method3()。然后，创建了一个接口适配器 InterfaceAdapter，该适配器实现了 TargetInterface 接口，并提供了默认的方法实现。最后，创建了一个具体适配器类 ConcreteAdapter，该适配器重写了 method2() 方法，并实现了适配的逻辑。

在测试代码中，创建了一个具体适配器对象 adapter，并通过该对象调用了目标接口的方法。在调用 adapter.method2() 时，会执行具体适配器 ConcreteAdapter 中的实现逻辑，而不是使用默认的实现。```

3、对象适配器

以下是一个简单的对象适配器的 Java 代码示例：

// 目标接口
interface Target {
    void request();
}

// 适配者类
class Adaptee {
    public void specificRequest() {
        System.out.println("适配者的方法被调用");
    }
}

// 对象适配器类
class ObjectAdapter implements Target {
    private Adaptee adaptee;

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

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

// 客户端类
public class Client {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target target = new ObjectAdapter(adaptee);
        target.request();
    }
}

这个示例中，目标接口 Target 定义了客户端所需的方法 request()。适配者类 Adaptee 是一个已存在的类，其中包含了一个可以被调用的方法 specificRequest()。对象适配器 ObjectAdapter 实现了 Target 接口，并在其内部持有一个 Adaptee 对象。在 ObjectAdapter 的 request() 方法中，通过调用 adaptee.specificRequest() 实现了适配器模式。最后，在客户端 Client 中创建了一个适配者对象和一个适配器对象，并调用适配器的 request() 方法来完成客户端的需求。

四、总结

1、适配器模式

适配器模式（Adapter Pattern）是一种结构型设计模式，它允许现有的类与其他类或接口进行协作，解决了类之间接口不兼容的问题。

2、适配器模式的优点

1. 透明性：适配器模式可以使客户端代码不需要修改就能与新的接口协作，提高了代码的可维护性和可复用性。
2. 扩展性：适配器模式可以在不修改现有代码的情况下添加新的适配器类，满足未来可能的需求变化。
3. 重用性：适配器模式可以重用现有的类，以适应不同的接口需求。
4. 灵活性：适配器模式可以根据需要选择合适的适配器类，实现不同的适配需求。

3、适配器模式的缺点

1. 增加代码复杂性：适配器模式需要新建适配器类，并编写适配器代码，增加了代码的复杂性和阅读性。
2. 运行效率低：由于适配器模式的存在，导致系统中多了一层间接调用，可能会对系统的性能有所影响。

总的来说，适配器模式是一种在接口不兼容的情况下，实现两个不同接口间的协作的有效方式，但在使用时需要权衡代码复杂性和运行效率。