设计模式-结构型模式-适配器模式
概述
适配器模式 : Adapter Pattern 是一种结构型设计模式.
作用 ： 使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
实现思路 ： 适配器模式通过将一个类的接口转换成客户希望的另外一个接口来实现这一点。
这里的“接口”指的是类所提供的方法、属性等成员的集合，并非特指面向对象编程语言中的interface。
简单理解 ： 适配器模式，就是 中间加一层，把原来的对象包装一下，转换成目标希望的样子。
角色
适配者(Source)：需要被适配的类。适配者包含客户想要使用但是接口与目标不兼容的方法。
目标(Target)接口：这是客户所期待的接口。在某些情况下，这个角色可能是一个具体类，而不是接口。
适配器(Adapter)：负责将适配者的接口转换为目标接口，从而使原本因为接口不匹配而无法合作的类能够协同工作。
分类
适配器模式分为三类 ：
类适配器模式、对象适配器模式、接口适配器模式。
类适配器模式
在不改变原有类结构的情况下，扩展类的功能，以适配不同的接口时，可以使用【类适配器模式】。
【实现思路】 ： 适配器类 继承 原来的类，并实现目标接口。
【实现效果】 ： 对原有类的方法，按照 目标接口中的要求进行“包装”，达到适配的效果。
以电源为例，标准的输出电压为220V （适配者），
现在需要给手机/手环 （目标接口）充电，手机要求的电压为 5V，手环要求的电压为 2V ，
此时，就需要 一个充电器（适配器）来进行电压的转换。
类图如下 ：
适配者类
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;
}
}
目标接口
public interface PhoneCharge {
int outPutTargetVoltage();
}
适配器类
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;
}
}
客户端类
public class Phone {
// 需要使用到 接口类型
private PhoneCharge phoneCharge;
public Phone(PhoneCharge phoneCharge) {
this.phoneCharge = phoneCharge;
}
// 使用接口中的目标方法即可
public void charge() {
int voltage = phoneCharge.outPutTargetVoltage();
System.out.println("手机获取到的充电电压 = " + voltage);
}
}
测试类
public class Client {
public static void main(String[] args) {
Phone phone = new Phone(new PhoneAdapter(220));
phone.charge();
}
}
运行结果 ：
适配者Power 类中 电压 = 220
手机适配器中的 电压 = 5
手机获取到的充电电压 = 5
对象适配器模式
对象适配器模式 ：
1、将 适配者类的对象 作为 适配器类的一个 成员变量；
2、适配器类实现 目标接口。
通过 持有适配者类的对象 + 实现目标接口的方式，对原来的逻辑进行扩展。
类图的结构如下：
适配者类
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;
}
}
目标接口
public interface PhoneCharge {
int outPutTargetVoltage();
}
适配器类
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;
}
}
客户端类
public class Phone {
private PhoneCharge phoneCharge;
public Phone(PhoneCharge phoneCharge) {
this.phoneCharge = phoneCharge;
}
public void charge() {
int voltage = phoneCharge.outPutTargetVoltage();
System.out.println("手机获取到的充电电压 = " + voltage);
}
}
测试类
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、然后通过继承该抽象类的方式，只重写部分需要的方法，达到简化代码的效果。
类图如下：
接口
public interface Say {
void sayHello();
void sayBye();
void sayHi();
void sayHaha();
}
抽象实现类
public class SayAbstractImpl implements Say{
@Override
public void sayHello() {}
@Override
public void sayBye() {}
@Override
public void sayHi() {}
@Override
public void sayHaha() {}
}
子类
public class SayHelloAndBye extends SayAbstractImpl{
@Override
public void sayHello() {
System.out.println(" sayHello : hello ");
}
@Override
public void sayBye() {
System.out.println(" sayBye : bye ");
}
}
测试类
public class Test {
public static void main(String[] args)
{
Say say = new SayHelloAndBye();
say.sayHello();
say.sayBye();
}
}
运行结果：
sayHello : hello
sayBye : bye
至此，适配器模式的三种使用方式就介绍完成了。