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

概述

适配器模式 : Adapter Pattern 是一种结构型设计模式.
作用：使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
实现思路 ：适配器模式通过将一个类的接口转换成客户希望的另外一个接口 来实现这一点。
这里的"接口"指的是类所提供的方法、属性等成员的集合，并非特指面向对象编程语言中的interface。

复制代码

简单理解 ： 适配器模式，就是 中间加一层，把原来的对象包装一下，转换成目标希望的样子。

角色

适配者(Source) ：需要被适配的类。适配者包含客户想要使用但是接口与目标不兼容的方法。
目标(Target)接口 ：这是客户所期待的接口。在某些情况下，这个角色可能是一个具体类，而不是接口。
适配器(Adapter) ：负责将适配者的接口 转换为目标接口，从而使原本因为接口不匹配而无法合作的类能够协同工作。

分类

适配器模式分为三类： 类适配器模式、对象适配器模式、接口适配器模式。

类适配器模式

在不改变原有类结构的情况下，扩展类的功能，以适配不同的接口时，可以使用【类适配器模式】。

【实现思路 】：适配器类继承原来的类，并实现目标接口。

【实现效果】：对原有类的方法，按照目标接口中的要求进行"包装"，达到适配的效果。

复制代码

以电源为例，标准的输出电压为220V （适配者），
现在需要给手机/手环 （目标接口）充电，手机要求的电压为 5V，手环要求的电压为 2V ，
此时，就需要 一个充电器（适配器）来进行电压的转换。

类图如下 ：

适配者类

java 复制代码

public class Power {
    private int voltage;

    public Power() {
    }

    public Power(int voltage) {
        this.voltage = voltage;
    }
// 这个就是要被适配包装的方法
   public int outPutVoltage() {
       System.out.println("适配者Power 类中 电压 = " + voltage);
       return voltage;
   }
}

目标接口

java 复制代码

public interface PhoneCharge {
    int outPutTargetVoltage();
}

适配器类

java 复制代码

public class PhoneAdapter extends Power implements PhoneCharge{

    public PhoneAdapter() {
    }

    public PhoneAdapter(int voltage) {
        super(voltage);
    }

// 重写目标接口中的方法 ： 核心 ： 适配的逻辑就在这里
    @Override
    public int outPutTargetVoltage() {

        // 获取到原来的电压
        int voltageSource = super.outPutVoltage();
        int targetVoltage = voltageSource/44;
        System.out.println("手机适配器中的 电压 = " + targetVoltage);

        return targetVoltage;
    }
}

客户端类

java 复制代码

public class Phone {

  // 需要使用到 接口类型
    private PhoneCharge phoneCharge;

    public Phone(PhoneCharge phoneCharge) {
        this.phoneCharge = phoneCharge;
    }

// 使用接口中的目标方法即可
    public void charge() {
        int voltage = phoneCharge.outPutTargetVoltage();
        System.out.println("手机获取到的充电电压 = " + voltage);
    }

}

测试类

java 复制代码

public class Client {
    public static void main(String[] args) {
        Phone phone = new Phone(new PhoneAdapter(220));
        phone.charge();
    }
}

复制代码

运行结果 ： 
适配者Power 类中 电压 = 220
手机适配器中的 电压 = 5
手机获取到的充电电压 = 5

对象适配器模式

对象适配器模式：

1、将 适配者类的对象 作为 适配器类 的一个 成员变量 ；

2、适配器类 实现目标接口。
通过持有适配者类的对象 + 实现目标接口的方式，对原来的逻辑进行扩展。

类图的结构如下：

适配者类

java 复制代码

public class Power {
    private int voltage;

    public Power() {
    }

    public Power(int voltage) {
        this.voltage = voltage;
    }
    
   public int outPutVoltage() {
       System.out.println("适配者Power 类中 电压 = " + voltage);
       return voltage;
   }
}

目标接口

java 复制代码

public interface PhoneCharge {
    int outPutTargetVoltage();
}

适配器类

java 复制代码

public class PhoneAdapter  implements PhoneCharge{

    // 直接作为成员变量放进来
    private Power power;

    public PhoneAdapter() {
    }

    public PhoneAdapter(Power power) {
        this.power = power;
    }

    @Override
    public int outPutTargetVoltage() {

        // 通过适配者类的对象，获取到原来的电压
        int voltageSource = power.outPutVoltage();
        int targetVoltage = voltageSource/44;
        System.out.println("手机适配器中的 电压 = " + targetVoltage);

        return targetVoltage;
    }
}

客户端类

java 复制代码

public class Phone {

    private PhoneCharge phoneCharge;

    public Phone(PhoneCharge phoneCharge) {
        this.phoneCharge = phoneCharge;
    }

    public void charge() {
        int voltage = phoneCharge.outPutTargetVoltage();
        System.out.println("手机获取到的充电电压 = " + voltage);
    }

}

测试类

java 复制代码

public class Client {
    public static void main(String[] args) {
        // 创建电源对象，当然这个对象也可以独立使用
        Power power = new Power(220);
        Phone phone = new Phone(new PhoneAdapter(power));
        phone.charge();
    }
}

复制代码

运行结果 ： 
适配者Power 类中 电压 = 220
手机适配器中的 电压 = 5
手机获取到的充电电压 = 5

接口适配器模式

接口适配模式 ，主要应用在 不希望实现所有的接口方法的情况下。
1、创建一个抽象类，给接口中的方法一个默认的实现；

2、然后通过继承该抽象类的方式，只重写部分需要的方法 ，达到简化代码的效果。

类图如下：

接口

java 复制代码

public interface Say {
    void sayHello();
    void sayBye();
    void sayHi();
    void sayHaha();
}

抽象实现类

java 复制代码

public class SayAbstractImpl implements Say{
    @Override
    public void sayHello() {}

    @Override
    public void sayBye() {}

    @Override
    public void sayHi() {}

    @Override
    public void sayHaha() {}
}

子类

java 复制代码

public class SayHelloAndBye extends SayAbstractImpl{
    @Override
    public void sayHello() {
        System.out.println(" sayHello  : hello ");
    }

    @Override
    public void sayBye() {
        System.out.println(" sayBye : bye ");
    }
}

测试类

java 复制代码

public class Test {
    public static void main(String[] args)
    {
        Say say = new SayHelloAndBye();
        say.sayHello();
        say.sayBye();
    }
}

复制代码

运行结果：
 sayHello  : hello 
 sayBye : bye

至此，适配器模式的三种使用方式就介绍完成了。