ToB企服应用市场:ToB评测及商务社交产业平台

标题: 【Kotlin筹划模式】Kotlin实现适配器模式 [打印本页]
作者: 怀念夏天    时间: 2024-8-28 00:31
标题: 【Kotlin筹划模式】Kotlin实现适配器模式
前言


适配器模式(Adapter Pattern)的焦点将某个类的接口转换成客户端期望的另一个接口表示，使得客户端可以或许通过本身期望的接口与不兼容的类进行交互。适配器模式有三种实现方式，分别是类适配器模式、对象适配器模式、 接口适配器模式。
我们假设有个视频输出盒子，当前只能接收和输出HDMI信号，现在客户的输入设备只能输出VGA信号，则我们可以通过转换器（要适配的类），将VGA信号转换成HDMI信号做输出。



实现


1、类适配器模式

客户目的接口，客户的新设备只能输出VGA信号，无法输出HDMI信号。
  2. /**
  3. * 客户目标输入接口
  4. */
  5. interface SourceInput {
  6.     fun inputVGA(signal:String)
  7. }
复制代码
Modem盒子只接收且输出HDMI信号，调制后输出给到显示设备进行显示。
  2. /**
  3. * 要适配的类
  4. */
  5. open class ModemOutput {
  6.     fun outputHDMI(signal:String){
  7.         println("设备输出${signal}给显示设备")
  8.     }
  9. }
复制代码
新的输入设备输出VGA模拟信号不满足现在的需求，我们通过定义转换器OutputAdapter，将VGA模拟信号转化成HDMI数字信号进行输出到Modem盒子中。
  2. /**
  3. * 转换器
  4. */
  5. class OutputAdapter : ModemOutput(), SourceInput {
  7.     override fun inputVGA(signal: String) {
  8.         if ("VGA模拟信号" == signal) {
  9.             println("【转HDMI信号转换器】>> 接收到了源设备，输入的${signal}")
  10.             val digital = convertVGAToHDMI(signal)
  11.             outputHDMI(digital)
  12.         } else {
  13.             throw IllegalArgumentException("输入信号错误")
  14.         }
  15.     }
  17.     private fun convertVGAToHDMI(signal: String): String {
  18.         println("【转HDMI信号转换器】>> 转化器将${signal}转化成HDMI数字信号")
  19.         return "HDMI数字信号"
  20.     }
  21. }
复制代码
客户端
  2. val adapter = OutputAdapter() as SourceInput
  3. adapter.inputVGA("VGA模拟信号")
  5. // 【转HDMI信号转换器】>> 接收到了源设备，输入的VGA模拟信号
  6. // 【转HDMI信号转换器】>> VGA转HDMI转化器将VGA模拟信号转化成HDMI数字信号
  7. //  设备输出HDMI数字信号给显示设备
复制代码
适配器类必要继承ModemOutput，Java是单继承模式，以是目的文件必须要是接口。

2、对象适配器模式

对象适配器模式较类适配器模式相比，原来的适配器不再继承要适配的类，将其作为适配器的构造参数传入，把继承解耦。
  2. /**
  3. * 要适配的类
  4. */
  5. open class ModemOutput {
  6.     fun outputHDMI(signal:String){
  7.         println("设备输出${signal}给显示设备")
  8.     }
  9. }
复制代码
  2. /**
  3. * 目标接口
  4. */
  5. interface SourceInput {
  6.     fun inputVGA(signal:String)
  7. }
复制代码
  3. /**
  4. * 转换器
  5. */
  6. class OutputAdapter(output: ModemOutput) : SourceInput {
  8.     private var mOutput:ModemOutput = output
  10.     override fun inputVGA(signal: String) {
  11.         if ("VGA模拟信号" == signal) {
  12.             println("【转HDMI信号转换器】>> 接收到了源设备，输入的${signal}")
  13.             val digital = convertVGAToHDMI(analog)
  14.             mOutput.outputHDMI(signal)
  15.         } else {
  16.             throw IllegalArgumentException("输入信号错误")
  17.         }
  18.     }
  20.     private fun convertVGAToHDMI(signal: String): String {
  21.         println("【转HDMI信号转换器】>> VGA转HDMI转化器将${signal}转化成HDMI数字信号")
  22.         return "HDMI数字信号"
  23.     }
  25. }
复制代码

3、接口适配器模式

接口适配器模式实用于目的接口中有多个方法，上面我们举了个目的接口中输入VGA的例子，如果还有DP接口、DVI接口的输入，适配器类在实现目的接口时候就要都实现其他的方法，但是客户端输入只有一种，不必要实现全部接口时，如果适配器定义抽象类来实现接口，而且接口中方法空实现，可以灵活解决这个问题。
目的接口新增格式信源输入方法，要适配的类稳固。
  2. /**
  3. * 目标接口
  4. */
  5. interface SourceInput {
  6.     fun inputVGA(signal:String)
  7.     fun inputDP(signal:String)
  8.     fun inputDVI(signal:String)
  9. }
复制代码
  2. /**
  3. * 要适配的类
  4. */
  5. open class ModemOutput {
  6.     fun outputHDMI(signal:String){
  7.         println("设备输出${signal}给显示设备")
  8.     }
  9. }
复制代码
新增抽象类，继承源文件ModemOutput、实现目的接口，覆写空方法，不做详细实现。
  2. abstract class OutputAdapter:ModemOutput(),SourceInput {
  4.     override fun inputDP(signal: String) {
  5.         TODO("Not yet implemented")
  6.     }
  8.     override fun inputDVI(signal: String) {
  9.         TODO("Not yet implemented")
  10.     }
  12.     override fun inputVGA(signal: String) {
  13.         TODO("Not yet implemented")
  14.     }
  15. }
复制代码
客户端只根据本身必要的，详细实现信号输入方法。
  2. val adapter = object : OutputAdapter() {
  3.          override fun inputDVI(signal: String) {
  4.              super.inputDVI(signal)
  5.              println("【转HDMI信号转换器】>> 接收到了源设备，输入的${signal}")
  6.              val digital = convertSignalToHDMI(signal)
  7.              outputHDMI(digital)
  8.          }
  9.      }
  12. private fun convertSignalToHDMI(signal: String): String {
  13.      when (signal) {
  14.          "VGA信号" -> {
  15.              println("【转HDMI信号转换器】>> 转HDMI转化器将${signal}转化成HDMI数字信号")
  16.          }
  17.          "DP信号" -> {
  18.              println("【转HDMI信号转换器】>> 转HDMI转化器将${signal}转化成HDMI数字信号")
  19.          }
  20.          "DVI信号" -> {
  21.              println("【转HDMI信号转换器】>> 转HDMI转化器将${signal}转化成HDMI数字信号")
  22.          }
  23.          else ->{
  24.              throw IllegalArgumentException("输入信号格式不支持")
  25.          }
  26.      }
  27.      return "HDMI数字信号"
  28. }
复制代码

总结


适配器模式可以以类适配器或对象适配器的形式实现，灵活性高。类适配器利用多重继承（在Java中通过接口实现），对象适配器通过组合来实现，本来由于接口不兼容而无法一起工作的类可以协同工作，从而进步了代码的复用性，答应通过引入新的适配器来顺应新需求，而无需修改现有的代码，从而实现了开闭原则。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4