• 万字解析设计模式之 适配器模式

    一、 适配器模式

    1.1概述

    将一个接口转换成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作。

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

    适配器模式的实现有两种方式： 类适配器：一次最多只能适配一个适配者类，不能同时适配多个适配者；适配者类不能为最终类；目标抽象类只能为接口，不能为类。 对象适配器：可以把多个不同的适配者适配到同一个目标，还可以适配一个适配者的子类；在适配器中置换适配者类的某些方法比较麻烦。

     1.2结构

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

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

    1.3 类适配器模式

    实现方式：定义一个适配器类来实现当前系统的业务接口，同时又继承现有组件库中已经存在的组件。

    【例】读卡器

    现有一台电脑只能读取SD卡，而要读取TF卡中的内容的话就需要使用到适配器模式。创建一个读卡器，将TF卡中的内容读取出来。

    类图如下：

    目标（Target）接口

    1. package com.yanyu.Adapter1;
    2.  
    3.  
    4. //SD卡的接口
    5. public interface SDCard {
    6.     //读取SD卡方法
    7.     String readSD();
    8.     //写入SD卡功能
    9.     void writeSD(String msg);
    10. }
    1. package com.yanyu.Adapter1;
    2.  
    3. //SD卡实现类
    4. public class SDCardImpl implements SDCard {
    5.     public String readSD() {
    6.         String msg = "sd card read a msg :hello word SD";
    7.         return msg;
    8.     }
    9.     public void writeSD(String msg) {
    10.         System.out.println("sd card write msg : " + msg);
    11.     }
    12. }

    适配者（Adaptee）类：

    1. package com.yanyu.Adapter1;
    2.  
    3. //TF卡接口
    4. public interface TFCard {
    5.     //读取TF卡方法
    6.     String readTF();
    7.     //写入TF卡功能
    8.     void writeTF(String msg);
    9. }
    1. package com.yanyu.Adapter1;
    2.  
    3. //TF卡实现类
    4. public class TFCardImpl implements TFCard {
    5.     public String readTF() {
    6.         String msg ="tf card read msg : hello word tf card";
    7.         return msg;
    8.     }
    9.     public void writeTF(String msg) {
    10.         System.out.println("tf card write a msg : " + msg);
    11.     }
    12. }

    适配器（Adapter）类

    1. package com.yanyu.Adapter1;
    2.  
    3. //定义适配器类（SD兼容TF）
    4. public class SDAdapterTF extends TFCardImpl implements SDCard {
    5.     //继承了TFCardImpl类，实现了TF卡的读写功能，并且实现了SDCard接口，使其兼容SD卡
    6.  
    7.     //实现SD卡的读取方法
    8.     public String readSD() {
    9.         System.out.println("adapter read tf card "); //打印提示信息
    10.         return readTF(); //调用TF卡的读取方法
    11.     }
    12.  
    13.     //实现SD卡的写入方法
    14.     public void writeSD(String msg) {
    15.         System.out.println("adapter write tf card"); //打印提示信息
    16.         writeTF(msg); //调用TF卡的写入方法
    17.     }
    18. }

    客户端类

    1. package com.yanyu.Adapter1;
    2.  
    3. //电脑类
    4. public class Computer {
    5.     public String readSD(SDCard sdCard) {
    6.         if(sdCard == null) {
    7.             throw new NullPointerException("sd card null");
    8.         }
    9.         return sdCard.readSD();
    10.     }
    11. }
    1. package com.yanyu.Adapter1;
    2.  
    3. //测试类
    4. public class Client {
    5.     public static void main(String[] args) {
    6.         Computer computer = new Computer(); //创建计算机对象
    7.         SDCard sdCard = new SDCardImpl(); //创建SD卡对象
    8.         System.out.println(computer.readSD(sdCard)); //在计算机上读取SD卡的内容并打印
    9.         System.out.println("------------");
    10.  
    11.         SDAdapterTF adapter = new SDAdapterTF(); //创建SD适配器对象
    12.         System.out.println(computer.readSD(adapter)); //在计算机上使用适配器读取TF卡的内容并打印
    13.     }
    14. }

    类适配器模式违背了合成复用原则。类适配器是客户类有一个接口规范的情况下可用，反之不可用。

    1.4对象适配器模式

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

    【例】读卡器

    我们使用对象适配器模式将读卡器的案例进行改写。类图如下：

    代码如下：

    类适配器模式的代码，我们只需要修改适配器类（SDAdapterTF）和测试类。

    1. package com.yanyu.Adapter1;
    2.  
    3. //定义适配器类（SD兼容TF）
    4.  
    5. //创建适配器对象（SD兼容TF）
    6. public class SDAdapterTF  implements SDCard {
    7.     private TFCard tfCard;
    8.     public SDAdapterTF(TFCard tfCard) {
    9.         this.tfCard = tfCard;
    10.     }
    11.     public String readSD() {
    12.         System.out.println("adapter read tf card ");
    13.         return tfCard.readTF();
    14.     }
    15.     public void writeSD(String msg) {
    16.         System.out.println("adapter write tf card");
    17.         tfCard.writeTF(msg);
    18.     }
    19. }
    1. package com.yanyu.Adapter1;
    2.  
    3. //测试类
    4. public class Client {
    5.     public static void main(String[] args) {
    6.         Computer computer = new Computer(); //创建计算机对象
    7.         SDCard sdCard = new SDCardImpl(); //创建SD卡对象
    8.         System.out.println(computer.readSD(sdCard)); //在计算机上读取SD卡的内容并打印
    9.         System.out.println("------------");
    10.  
    11.         TFCard tfCard = new TFCardImpl();
    12.         SDAdapterTF adapter = new SDAdapterTF(tfCard); //创建SD适配器对象
    13.         System.out.println(computer.readSD(adapter)); //在计算机上使用适配器读取TF卡的内容并打印
    14.     }
    15. }

    注意：还有一个适配器模式是接口适配器模式。当不希望实现一个接口中所有的方法时，可以创建一个抽象类Adapter ，实现所有方法。而此时我们只需要继承该抽象类即可。

    1.5 应用场景

    适应的场景：

    • 系统需要使用一些现有的类，而这些类的接口不符合系统的需要，甚至没有这些类的源代码；
    • 创建一个可以重复使用的类，用于和一些彼此之间没有太大关联的类，包括一些可能在将来引进的类一起工作。
    • 以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致。
    • 使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同。

    1.6JDK源码解析

    在JDK中，有很多使用了适配器模式的地方，其中最常见的是集合框架中的迭代器。迭代器是一种提供对集合元素进行访问的机制，它通常被用于循环遍历集合中的元素。在集合框架中，每个集合都提供了一个迭代器，使得可以使用通用的方式对其进行遍历。

    另一个使用适配器模式的例子是JDBC(Java DataBase Connectivity)。JDBC是一种用于连接数据库的API，它提供了一系列的接口。其中，Connection、Statement和ResultSet是最常用的接口。JDBC还提供了一种叫做DriverManager的类，它提供了一个用于建立数据库连接的静态方法getConnection()。在JDBC中，不同的数据库供应商会提供不同的驱动程序，这些驱动程序都实现了JDBC的接口。JDBC驱动程序通常被封装在一个适配器中，使得它们可以与JDBC API协同工作。

    二、实验

    任务描述

    现有一个接口 DataOperation 定义了排序方法 sort(int[]) 和查找方法 search(int[],int)，已知类 QuickSort 的 quickSort(int[]) 方法实现了快速排序算法，类 BinarySearch 的 binarySearch(int[],int) 方法实现了二分查找算法。

    本关任务：现使用适配器模式设计一个系统，在不修改源代码的情况下将类 QuickSort 和类 BinarySearch 的方法适配到 DataOperation 接口中。

    ,

    实现方式

    1. 确保至少有两个类的接口不兼容：一个无法修改 （通常是第三方、 遗留系统或者存在众多已有依赖的类） 的功能性服务类。一个或多个将受益于使用服务类的客户端类。
    2. 声明客户端接口， 描述客户端如何与服务交互。
    3. 创建遵循客户端接口的适配器类。 所有方法暂时都为空。
    4. 在适配器类中添加一个成员变量用于保存对于服务对象的引用。 通常情况下会通过构造函数对该成员变量进行初始化， 但有时在调用其方法时将该变量传递给适配器会更方便。
    5. 依次实现适配器类客户端接口的所有方法。 适配器会将实际工作委派给服务对象， 自身只负责接口或数据格式的转换。
    6. 客户端必须通过客户端接口使用适配器。 这样一来， 你就可以在不影响客户端代码的情况下修改或扩展适配器。

    编程要求

    根据提示，在右侧编辑器 Begin-End 内补充 "OperationAdapter.java" 的代码，计算并输出结果。其它文件不需要修改。

    测试说明

    平台会对你编写的代码进行测试：第一行输入数组个数，第二行输入数组元素，第三行输出需要查询的数。查询的结果 1 表示“找到了”，-1 表示“没有找到”

    测试输入： 7； 41 2 58 12 66 98 5； 12； 预期输出： 实现快速排序： 2 5 12 41 58 66 98 实现了二分查找算法： 1

    测试输入： 8； 58 40 12 66 77 5 48 23； 10； 预期输出： 实现快速排序： 5 12 23 40 48 58 66 77 实现了二分查找算法： -1

    目标接口

    1. package step1;
    2.  
    3. public interface DataOperation {
    4.     public void sort(int array[]);
    5.     public int search(int array[],int key);
    6. }

    DataOperation接口定义了客户端代码所期望的操作，即sort和search方法，而适配器将快速排序和二分查找算法适配到这个接口中，使得客户端可以统一调用这两种算法。

    适配者（Adaptee）类

    1. package step1;
    2.  
    3. public class BinarySearch {
    4.     public int binarySearch(int array[],int key)
    5.     {
    6.         int low = 0;
    7.         int high = array.length -1;
    8.         while(low <= high)
    9.         {
    10.             int mid = (low + high) / 2;
    11.             int midVal = array[mid];
    12.  
    13.             if(midVal < key)
    14.             {
    15.                 low = mid +1;
    16.             }
    17.             else if(midVal > key)
    18.             {
    19.                 high = mid -1;
    20.             }
    21.             else
    22.             {
    23.                 return 1; //找到元素返回1
    24.             }
    25.         }
    26.         return -1;  //未找到元素返回-1
    27.     }
    28.  
    29. }
    1. package step1;
    2.  
    3. public class QuickSort {
    4.     public int[] quickSort(int array[])
    5.     {
    6.         sort(array,0,array.length-1);
    7.         return array;
    8.     }
    9.     public void sort(int array[],int p, int r)
    10.     {
    11.         int q=0;
    12.         if(p
    13.         {
    14.             q=partition(array,p,r);
    15.             sort(array,p,q-1);
    16.             sort(array,q+1,r);
    17.         }
    18.     }
    19.     public int partition(int[] a, int p, int r)
    20.     {
    21.         int x=a[r];
    22.         int j=p-1;
    23.         for(int i=p;i<=r-1;i++)
    24.         {
    25.             if(a[i]<=x)
    26.             {
    27.                 j++;
    28.                 swap(a,j,i);
    29.             }
    30.         }
    31.         swap(a,j+1,r);
    32.         return j+1;
    33.     }
    34.     public void swap(int[] a, int i, int j)
    35.     {
    36.         int t = a[i];
    37.         a[i] = a[j];
    38.         a[j] = t;
    39.     }
    40. }

    适配器（Adapter）类

    1. package step1;
    2.  
    3. /********** Begin *********/
    4. // OperationAdapter类实现了DataOperation接口，将QuickSort和BinarySearch适配到DataOperation接口中
    5.  
    6. public class OperationAdapter implements DataOperation{
    7.     private QuickSort qSort; // 适配者1：快速排序算法
    8.     private BinarySearch binarySearch; // 适配者2：二分查找算法
    9.  
    10.     // 构造方法，接收快速排序和二分查找算法对象
    11.     public OperationAdapter(QuickSort qSort, BinarySearch binarySearch){
    12.         this.qSort = qSort;
    13.         this.binarySearch = binarySearch;
    14.     }
    15.  
    16.     // 实现DataOperation接口中的sort方法，调用适配者1的快速排序算法
    17.     public void sort(int[] array){
    18.         qSort.quickSort(array);
    19.     }
    20.  
    21.     // 实现DataOperation接口中的search方法，调用适配者2的二分查找算法
    22.     public int search(int[] array, int key){
    23.         return binarySearch.binarySearch(array, key);
    24.     }
    25. }
    26. /********** End *********/

    客户端类

    1. package step1;
    2.  
    3. import java.util.Scanner;
    4.  
    5. public class Client {
    6.     public static void main(String[] args) {
    7.         // 创建适配者模式的适配器对象，将快速排序和二分查找算法适配到统一的接口
    8.         DataOperation dataOperation = new OperationAdapter(new QuickSort(),new BinarySearch());
    9.         int i = 0;
    10.         Scanner scanner = new Scanner(System.in);
    11.         int count = scanner.nextInt();
    12.         int[] array = new int[count];
    13.         // 读取输入的数组元素
    14.         while (scanner.hasNext()) {
    15.             array[i++] = scanner.nextInt();
    16.             if (i == array.length) {
    17.                 break;
    18.             }
    19.         }
    20.         int key = scanner.nextInt();
    21.         // 使用适配者模式调用快速排序算法
    22.         dataOperation.sort(array);
    23.         System.out.println("实现快速排序：");
    24.         // 输出排序后的数组
    25.         for(i = 0; i
    26.             System.out.print(array[i]+" ");
    27.         }
    28.         System.out.println("\n"+"实现了二分查找算法：");
    29.         // 使用适配者模式调用二分查找算法
    30.         System.out.println(dataOperation.search(array, key));
    31.     }
    32. }

     

  • 相关阅读:
    Ajax——AJAX实现省市联动
    maui BlazorWebView+本地html (vue、uniapp等都可以) 接入微信sdk 开发 Android app
    JavaScript面试常见问题（二）
    HarmonyOS网络管理开发—HTTP与WebSocket
    zemax慧差与消慧差
    Redis基础知识解答
    java分数线查询系统(0)计算机毕业设计MyBatis+系统+LW文档+源码+调试部署
    计算机主机名与用户名区别
    spring源码-spring启动（待完善）
    2022年HNUCM信息科学与工程学院第五届新生赛——正式赛
  • 原文地址：https://blog.csdn.net/qq_62377885/article/details/134523077