结构型模式 - 适配器模式

系列文章目录

设计模式 - 设计原则

创建型模式 - 单例模式（一）
创建型模式 - 工厂模式（二）
创建型模式 - 原型模式（三）
创建型模式 - 建造者模式（四）

结构型模式 - 适配器模式（一）
结构型模式 - 桥接模式（二）
结构型模式 - 装饰器模式（三）
结构型模式 - 组合模式（四）
结构型模式 - 外观模式（五）
结构型模式 - 享元模式（六）
结构型模式 - 代理模式（七）

行为型模式 - 模板方法模式（一）
行为型模式 - 命令模式（二）
行为型模式 - 访问者模式（三）
行为型模式 - 迭代器模式（四）
行为型模式 - 观察者模式（五）
行为型模式 - 中介者模式（六）
行为型模式 - 备忘录模式（七）
行为型模式 - 解释器模式（八）
行为型模式 - 状态模式（九）
行为型模式 - 策略模式（十）
行为型模式 - 责任链模式（十一）

---

---

前言

代码地址

---

一、适配器模式

1.1 适配器模式介绍

• 适配器（Adapter）模式

• 又叫包装器（Wapper），是将一个接口转换成客户希望的另一个接口，使接口不兼容的那些类可以一起工作；
• 适配器模式分类：类适配器、对象适配器，接口适配器；

1.2 适配器模式结构

• 目标抽象（Target）类

• 当前系统业务所期待的接口，可以是抽象类或接口。；

• 适配者（Adaptee）类

• 即被适配的角色，是被访问和适配的现存组件库中的组件接口；

• 适配器（Adapter）类

• 它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按照目标接口的格式访问适配者；

1.3 适配器分类

• 作为一个适配器，必须要一手拿着被适配者（Adaptee），另一手拿着目标（Target），想要转变为目标，必须得和目标同一类型；

• 在OOP中，想要成为目标（Target）类型要么继承，要么实现；想要拥有被适配者（Adaptee），要么实现，要么继承，要么关联（拥有一个对象)三种方式

• 按照被适配者（Adaptee）进行划分：

  • 适配器如果继承 Adaptee，那么就是类适配器；
  • 适配器如果拥有一个 Adaptee，也就是拥有一个 Adaptee 对象，那么就是对象适配器；
  • 适配器如果实现了 Adaptee ，那么就是接口适配器；

二、实现

例子：

• 码农张三手机刷某宝刷没电了。
• 出租屋里面有插座提供的电压是220V交流电，但是手机充电电压是5V直流电，没法直接充电。
• 于是，张三找了个充电器给手机充电，在这里充电器本身相当于Adapter，220V交流电相当于Adaptee，5V直流电相当于Target；

2.1 类适配器实现

• Adapter 类继承 Adaptee（被适配类），同时实现 Target 接口（因为Java不支持多继承，所以只能通过接口方法来实现多继承），在 Client 类中我们可以根据需要选择并创建任一种符合需求的子类，来实现具体功能；

package com.dozezz.designpattern.adapter.cls;

/**
 * @Description: 被适配的类（Adaptee）
 * @Author: dozezz
 * @Date: 2021/7/16 20:13
 * @Version: 1.0
 */
public class Voltage220Adaptee {

    public int output220(){
        int adaptee = 220;
        System.out.println(String.format("Voltage220Adaptee 输出电压： %s V", adaptee));

        return adaptee;
    }
}

package com.dozezz.designpattern.adapter.cls;

/**
 * @Description: 目标类
 * @Author: dozezz
 * @Date: 2021/7/16 20:18
 * @Version: 1.0
 */
public interface IVoltage5Target {

    public  int output5();
}

package com.dozezz.designpattern.adapter.cls;

/**
 * @Description: 220V转换成5V适配器
 * @Author: dozezz
 * @Date: 2021/7/16 20:26
 * @Version: 1.0
 */
public class Voltage220To5Adapter extends Voltage220Adaptee implements IVoltage5Target {

    @Override
    public int output5() {
        //获取220V电压，转换成5V 电压，
        return output220() / 44;
    }

}

package com.dozezz.designpattern.adapter.cls;

/**
 * @Description:
 * @Author: dozezz
 * @Date: 2021/7/16 20:34
 * @Version: 1.0
 */
public class Phone {

    public  void charging(IVoltage5Target voltage5Target){
        System.out.println(String.format("Phone 电压：%s V，可以充电，充电中。。。", voltage5Target.output5()));
    }
}

package com.dozezz.designpattern.adapter;

import com.dozezz.designpattern.adapter.cls.Phone;
import com.dozezz.designpattern.adapter.cls.Voltage220To5Adapter;

/**
 * @Description: 测试类
 * @Author: dozezz
 * @Date: 2021/7/15 20:44
 * @Version: 1.0
 */
public class MainTest {
    public static void main(String[] args) {
        new Phone().charging(new Voltage220To5Adapter());
    }
}

• 优缺点：

  • Java 是单继承机制，所以类适配器需要继承 Adaptee 类这一点算是一个缺点，因为这要求 Target 类必须是接口，有一定的局限性；
  • 既然是继承被适配者（Adaptee），那么，被适配者的子类拥有的方法和行为，他并不能拥有，也就是说不能适配被适配者（Adaptee）的子类；
  • Adaptee 类的方法在 Adapter 类中都会暴露出来，增加了使用的成本；
  • 由于继承了 Adaptee 类，所以可以根据需求重写 Adaptee 类的方法，使得 Adapter 的灵活性增强了；

2.2 对象适配器实现

• 对象适配器与类适配器不同之处在于，类适配器通过继承来完成适配，对象适配器则通过关联来完成（把被适配者 Adaptee 当做一个属性对象放到适配器中），这里稍微改下Adapter 类即可转变为对象适配器；
• 对象适配器不要求目标一定是接口，继承和实现都是可以的；

package com.dozezz.designpattern.adapter.cls;

/**
 * @Description:
 * @Author: dozezz
 * @Date: 2021/7/16 20:37
 * @Version: 1.0
 */
public class Voltage220To5Adapter1 implements IVoltage5Target{

    private Voltage220Adaptee voltage220Adaptee = new Voltage220Adaptee();

    @Override
    public int output5() {
        //获取220V电压，转换成5V 电压，
        return voltage220Adaptee.output220() / 44;
    }

}

• 优缺点：

  • 根据合成复用原则，使用组合替代继承，所以它解决了类适配器必须继承 Adaptee 的局限性，也不再要求 Target 必须是接口；
  • 使用成本更低，更灵活；

2.3 接口适配器实现

• 当不需要 全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每一个方法提供一个默认实现（空方法），那么该抽象类的子类可有选择地覆盖父类的某些方法实现需求，它适用于一个接口不想使用其所有的方法的情况；
• 接口适配器的行为相当于适配了自己，把原来的接口当做被适配者 （Adaptee），目标则是实现了接口部分功能的类；

package com.dozezz.designpattern.adapter.inc;

/**
 * @Description:
 * @Author: dozezz
 * @Date: 2021/7/16 21:09
 * @Version: 1.0
 */
interface IVoltageTarget {

    public  String output3();

    public  String output5();

    public  String output12();

    public  String output24();

    public  String output48();

    public  String output110();
}

package com.dozezz.designpattern.adapter.inc;


/**
 * @Description: 接口適配類，相當於適配了自己
 * @Author: dozezz
 * @Date: 2021/7/16 21:10
 * @Version: 1.0
 */
public class AbstractAdpater implements IVoltageTarget{


    @Override
    public String output3() {
        return null;
    }

    @Override
    public String output5() {
        return null;
    }

    @Override
    public String output12() {
        return null;
    }

    @Override
    public String output24() {
        return null;
    }

    @Override
    public String output48() {
        return null;
    }

    @Override
    public String output110() {
        return null;
    }
}

package com.dozezz.designpattern.adapter.inc;

/**
 * @Description:
 * @Author: dozezz
 * @Date: 2021/7/16 20:34
 * @Version: 1.0
 */
public class XiaomiPhone{

    public  void charging(AbstractAdpater abstractAdpater){
        System.out.println(String.format("XiaomiPhone 电压：%s V，可以充电，充电中。。。", abstractAdpater.output5()));
    }
}

package com.dozezz.designpattern.adapter;

import com.dozezz.designpattern.adapter.inc.XiaomiPhone;
import com.dozezz.designpattern.adapter.inc.AbstractAdpater;

/**
 * @Description: 测试类
 * @Author: dozezz
 * @Date: 2021/7/15 20:44
 * @Version: 1.0
 */
public class Client {
    public static void main(String[] args) {
        new XiaomiPhone().charging(new AbstractAdpater(){
            @Override
            public String output5() {
                return "5V" ;
            }
        });
    }
}

2.4 双向适配器

• 既可以把被适配者（Adaptee） 转换成目标（Target），也可以把 目标（Target）转换成被适配者（Adaptee）；

package com.dozezz.designpattern.adapter.twoway;

/**
 * @Description: 被適配接口
 * @Author: dozezz
 * @Date: 2021/7/18 10:25
 * @Version: 1.0
 */
public interface IVoltageAdaptee {

    int output220();
}

package com.dozezz.designpattern.adapter.twoway;

/**
 * @Description: 被適配者實現類
 * @Author: dozezz
 * @Date: 2021/7/18 10:41
 * @Version: 1.0
 */
public class Voltage220Adaptee implements IVoltageAdaptee{
    @Override
    public int output220() {
        return 220;
    }
}

package com.dozezz.designpattern.adapter.twoway;

/**
 * @Description: 目標接口
 * @Author: dozezz
 * @Date: 2021/7/18 10:26
 * @Version: 1.0
 */
public interface IVoltageTarget {
    int output5();
}

package com.dozezz.designpattern.adapter.twoway;

/**
 * @Description: 目標類實現類
 * @Author: dozezz
 * @Date: 2021/7/18 10:42
 * @Version: 1.0
 */
public class Voltage5Target implements IVoltageTarget{
    @Override
    public int output5() {
        return 5;
    }
}

package com.dozezz.designpattern.adapter.twoway;

/**
 * @Description: 適配類
 * @Author: dozezz
 * @Date: 2021/7/18 10:30
 * @Version: 1.0
 */
public class VoltageAdapter implements IVoltageTarget, IVoltageAdaptee {

    private IVoltageAdaptee voltageAdaptee;

    private IVoltageTarget voltageTarget;

    public VoltageAdapter(IVoltageAdaptee voltageAdaptee) {
        this.voltageAdaptee = voltageAdaptee;
    }

    public VoltageAdapter(IVoltageTarget voltageTarget) {
        this.voltageTarget = voltageTarget;
    }

    @Override
    public int output220() {
        return voltageTarget.output5()*44;
    }

    @Override
    public int output5() {
        return voltageAdaptee.output220()/44;
    }

    public IVoltageAdaptee getVoltageAdaptee() {
        return voltageAdaptee;
    }

    public IVoltageTarget getVoltageTarget() {
        return voltageTarget;
    }
}

package com.dozezz.designpattern.adapter;

import com.dozezz.designpattern.adapter.twoway.Voltage220Adaptee;
import com.dozezz.designpattern.adapter.twoway.Voltage5Target;
import com.dozezz.designpattern.adapter.twoway.VoltageAdapter;

/**
 * @Description: 测试类
 * @Author: dozezz
 * @Date: 2021/7/15 20:44
 * @Version: 1.0
 */
public class Client {
    public static void main(String[] args) {
        VoltageAdapter voltageAdapter = new VoltageAdapter(new Voltage220Adaptee());
        System.out.println(String.format("被適配電壓： %dV, 目標電壓： %dV, 適配後輸出電壓：%d V", voltageAdapter.getVoltageAdaptee().output220(), 5, voltageAdapter.output5()));


        VoltageAdapter voltageAdapter1 = new VoltageAdapter(new Voltage5Target());
        System.out.println(String.format("被適配電壓： %dV, 目標電壓： %dV, 適配後輸出電壓：%d V", voltageAdapter1.getVoltageTarget().output5(), 220, voltageAdapter1.output220()));

    }
}

三、适配器模式总结

3.1 适配器模式适用场景

• 以前开发的系统存在满足新系统功能需求的类，但其接口同新系统不一致；
• 使用第三方提供的组件，但是组件接口定义和自己要求的接口定义不同；

四、参考文献

• http://c.biancheng.net/view/1354.html
• https://www.bilibili.com/video/BV1G4411c7N4?p=54&spm_id_from=pageDriver
• https://baiyp.ren/JAVA%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-04%E9%80%82%E9%85%8D%E5%99%A8%E6%A8%A1%E5%BC%8F.html