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

一、概述和使用场景

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   {@Overridepublic 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 {@Overridepublic void method1() {// 默认实现}@Overridepublic void method2() {// 默认实现}@Overridepublic void method3() {// 默认实现}
}// 具体适配器类
class ConcreteAdapter extends InterfaceAdapter {@Overridepublic 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;}@Overridepublic 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. 运行效率低：由于适配器模式的存在，导致系统中多了一层间接调用，可能会对系统的性能有所影响。

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