目录
一、适配器模式
一句话概括结构式模式
1.1、适配器模式概述
1.2、案例
1.2.1、类适配器模式实现案例
1.2.2、对象适配器
1.2.3、接口适配器
1.3、优缺点(对象适配器模式)
1.4、应用场景
一、适配器模式
一句话概括结构式模式
教你将类和对象结合再一起形成一个更强大的结构.
1.1、适配器模式概述
将一个类的接口转换成客户希望的另一个接口,使得原本不兼容的接口能一起工作.
比如,如果你使用的是苹果手机,那么就意味着充电器的充电口也是苹果标准的,而你现在只有一个 type-c 插孔的插座能充电,因此就需要一个转换器(一头type-c,另一头 苹果插头),就可以让原本不兼容的 苹果插头 一起工作.
适配器模式包含以下主机角色:
- 目标接口:当前客户所期待的接口,它可以是抽象类或者接口(上述的 苹果插头).
- 适配者类:是被访问的现存组件库中的接口(上述的 type-c).
- 适配器类:是一个转换器,通过继承或引用目标接口,实现适配者类的所有方法,就可以实现转换效果.
适配器模式分为 类适配器模式、对象适配器模式 ,其中类适配器耦合度最高(不符合合成/聚合复用原则),且要求程序员了解现有组件库的内部结构,因此应用较少.
还有一种模式叫 接口适配器模式,是对对象适配器的扩展.
1.2、案例
现有一台电脑,只能读取 SD 卡,而我现在只有一个 TF 卡,因此就需要使用适配器模式. 创建一个读卡器,将 TF 卡中的内容读取出来.
1.2.1、类适配器模式实现案例
类适配器只需要我们继承目标接口,实现适配者接口的所有方法即可.
/**
* 目标接口: TF 卡
*/
public interface TFCard {
/**
* 读取 TF 卡
* @return
*/
String readTF();
/**
* 写入 TF 卡
*/
void writeTF(String msg);
}
/**
* 目标接口实现类
*/
public class TFCardImpl implements TFCard{
@Override
public String readTF() {
String msg = "tf card readTF: hello!";
return msg;
}
@Override
public void writeTF(String msg) {
System.out.println("tf card writeTF: hello!");
}
}
/**
* 适配者接口: SD 卡
*/
public interface SDCard {
/**
* 读取 SD 卡
* @return
*/
String readSD();
/**
* 写入 SD 卡
*/
void writeSD(String msg);
}
/**
* 适配者实现类: SD 卡实现类
*/
public class SDCardImpl implements SDCard {
@Override
public String readSD() {
String msg = "sd card readTF: hello!";
return msg;
}
@Override
public void writeSD(String msg) {
System.out.println("sd card writeTF: " + msg);
}
}
/**
* 适配器:SD 兼容 TF
*/
public class SDAdapterTF extends TFCardImpl implements SDCard{
@Override
public String readSD() {
System.out.println("adapter read tf card");
return readTF();
}
@Override
public void writeSD(String msg) {
System.out.println("adapter write tf card");
writeTF(msg);
}
}
/**
* 电脑类
*/
public class Computer {
public String readSD(SDCard sdCard) {
if(sdCard == null) {
throw new NullPointerException("sd card null");
}
return sdCard.readSD();
}
}
public static void main(String[] args) {
//1.创建一个电脑类
Computer computer = new Computer();
//3.通过适配器从电脑中读取 TF 卡的数据
SDAdapterTF adapter = new SDAdapterTF();
String msg = computer.readSD(adapter);
System.out.println(msg);
}
1.2.2、对象适配器
对象适配器,相比于 类适配器,更符合 合成/聚合复用原则(持有新对象的引用,而不是通过继承来达到复用目的). 也就是说,它是通过持有目标接口的引用(tf 卡接口的引用),重写 适配者接口 的所有方法实现的 .
/**
* 目标接口: TF 卡
*/
public interface TFCard {
/**
* 读取 TF 卡
* @return
*/
String readTF();
/**
* 写入 TF 卡
*/
void writeTF(String msg);
}
/**
* 目标接口实现类
*/
public class TFCardImpl implements TFCard {
@Override
public String readTF() {
String msg = "tf card readTF: hello!";
return msg;
}
@Override
public void writeTF(String msg) {
System.out.println("tf card writeTF: hello!");
}
}
/**
* 适配者接口: SD 卡
*/
public interface SDCard {
/**
* 读取 SD 卡
* @return
*/
String readSD();
/**
* 写入 SD 卡
*/
void writeSD(String msg);
}
/**
* 适配者实现类: SD 卡实现类
*/
public class SDCardImpl implements SDCard {
@Override
public String readSD() {
String msg = "sd card readTF: hello!";
return msg;
}
@Override
public void writeSD(String msg) {
System.out.println("sd card writeTF: " + msg);
}
}
/**
* 适配器:SD 兼容 TF
*/
public class SDAdapterTF implements SDCard {
private TFCard tfCard;
public SDAdapterTF(TFCard tfCard) {
this.tfCard = tfCard;
}
@Override
public String readSD() {
System.out.println("adapter read tf card");
return tfCard.readTF();
}
@Override
public void writeSD(String msg) {
System.out.println("adapter write tf card");
tfCard.writeTF(msg);
}
}
/**
* 电脑类
*/
public class Computer {
public String readSD(SDCard sdCard) {
if(sdCard == null) {
throw new NullPointerException("sd card null");
}
return sdCard.readSD();
}
}
public class Client {
public static void main(String[] args) {
//1.创建一个电脑类
Computer computer = new Computer();
//3.通过适配器从电脑中读取 TF 卡的数据
SDAdapterTF adapter = new SDAdapterTF(new TFCardImpl());
computer.readSD(adapter);
}
}
1.2.3、接口适配器
当我们不希望实现一个适配者接口(sd 卡接口)中的所有方法时,可以创建一个抽象类 Adapter,实现所有方法(不用实现方法内容).此时我们只需要继承该抽象类,在重写我们需要的方法即可.
实现前两个适配器中,就一直没有使用 writeSD 方法,因此这里就不实现此方法.
/**
* 目标接口: TF 卡
*/
public interface TFCard {
/**
* 读取 TF 卡
* @return
*/
String readTF();
/**
* 写入 TF 卡
*/
void writeTF(String msg);
}
/**
* 目标接口实现类
*/
public class TFCardImpl implements TFCard {
@Override
public String readTF() {
String msg = "tf card readTF: hello!";
return msg;
}
@Override
public void writeTF(String msg) {
System.out.println("tf card writeTF: hello!");
}
}
/**
* 适配者接口: SD 卡
*/
public interface SDCard {
/**
* 读取 SD 卡
* @return
*/
String readSD();
/**
* 写入 SD 卡
*/
void writeSD(String msg);
}
/**
* 适配者实现类: SD 卡实现类
*/
public class SDCardImpl implements SDCard {
@Override
public String readSD() {
String msg = "sd card readTF: hello!";
return msg;
}
@Override
public void writeSD(String msg) {
System.out.println("sd card writeTF: " + msg);
}
}
public abstract class Adapter implements SDCard {
@Override
public void writeSD(String msg) {
}
@Override
public String readSD() {
return null;
}
}
public class SDAdapterTF extends Adapter implements SDCard{
private TFCard tfCard;
public SDAdapterTF(TFCard tfCard) {
this.tfCard = tfCard;
}
@Override
public String readSD() {
System.out.println("adapter read tf card");
return tfCard.readTF();
}
}
/**
* 电脑类
*/
public class Computer {
public String readSD(SDCard sdCard) {
if(sdCard == null) {
throw new NullPointerException("sd card null");
}
return sdCard.readSD();
}
}
public class Client {
public static void main(String[] args) {
//1.创建一个电脑类
Computer computer = new Computer();
//2.通过适配器从电脑中读取 TF 卡的数据
SDAdapterTF sdAdapterTF = new SDAdapterTF(new TFCardImpl());
String msg = computer.readSD(sdAdapterTF);
System.out.println(msg);
}
}
1.3、优缺点(对象适配器模式)
优点
1. 适配现有类,且不修改类:在不改变现有类的基础上,实现现有类和目标类的接口的匹配.
2. 符合 合成/聚合 复用原则:持有引用,而不继承.
3. 符合开闭原则:如果引入新的目标接口,只需要在适配器类中进行扩展,不需要修改原代码.
缺点:
增加复杂性:编写适配器类时,要考虑全面,包括适配者和目标类.
1.4、应用场景
1. 以前开发的系统中存在满足当前业务所需要的类,但是接口和当前业务所需接口不一致.
2. 第三方提供的组件,但是组件接口定义和自己要求的接口定义不同.