Java设计模式（五）—适配器模式、桥接模式、装饰者模式
本章目录
- 第九章 适配器模式
-
- 9.1 基本情况
- 9.2 类适配器
-
- 9.2.1 类适配器模式的类
- 9.2.2 应用案例
- 9.2.2 类适配器注意事项
- 9.3 对象适配器
-
- 9.3.1 基本介绍
- 9.3.2 应用案例
- 9.3.3 对象适配器的注意事项
- 9.4 接口适配器（缺省适配器）
-
- 9.4.1 基本介绍
- 9.4.2 应用案例
- 9.5 适配器模式的注意事项和细节
- 第十章 桥接模式
-
- 10.1 手机操作问题
- 10.2 桥接模式
- 10.3 桥接模式解决手机操作问题
- 10.4 桥接模式在 JDBC 的源码剖析
- 10.5 桥接模式的注意事项
- 第十一章 装饰者设计模式
-
- 11.1 星巴克咖啡订单项目（咖啡馆）
- 11.2 传统方案
- 11.3 装饰者模式
- 11.4 装饰者模式解决星巴克咖啡订单
- 11. 5 装饰者模式在JDK 应用的源码分析
第九章 适配器模式
9.1 基本情况
- 基本介绍
（1）适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示，主的目的是兼容性，让原本 因接口不匹配不能一起工作的两个类可以协同工作。其别名为包装器(Wrapper)
（2）适配器模式属于结构型模式
（3）主要分为三类：类适配器模式、对象适配器模式、接口适配器模式 - 工作原理
1（1）适配器模式：将一个类的接口转换成另一种接口.让原本接口不兼容的类可以兼容
（2） 从用户的角度看不到被适配者，是解耦的，用户收到反馈结果，感觉只是和目标接口交互
（3）用户调用适配器转化出来的目标接口方法，适配器再调用被适配者的相关接口方法 。如图
9.2 类适配器
9.2.1 类适配器模式的类
- 基本介绍：Adapter 类，通过继承 src 类，实现 dst 类接口，完成 src->dst 的适配。
- 类图
9.2.2 应用案例
- 使用案例
以充电器的例子来讲解适配器，充电器本身相当于 Adapter，220V 交流电相当于 src (即被适配者)，我们的目 dst(即 目标)是 5V 直流电 。 - 代码
（1）被适配类
//被适配的类
public class Voltage220V {
//输出220V的电压
public int output220V() {
int src = 220;
System.out.println("电压=" + src + "伏");
return src;
}
}
（2）适配接口
//适配接口
public interface IVoltage5V {
public int output5V();
}
（3）适配器类
//适配器类
public class VoltageAdapter extends Voltage220V implements IVoltage5V {
@Override
public int output5V() {
//获取到220V电压
int srcV = output220V();
int dstV = srcV / 44 ; //转成 5v
return dstV;
}
}
（4）手机类
public class Phone {
//充电
public void charging(IVoltage5V iVoltage5V) {
if(iVoltage5V.output5V() == 5) {
System.out.println("电压为5V, 可以充电~~");
} else if (iVoltage5V.output5V() > 5) {
System.out.println("电压大于5V, 不能充电~~");
}
}
}
（5）客户端
public class Client {
public static void main(String[] args) {
System.out.println(" === 类适配器模式 ====");
Phone phone = new Phone();
//因为是继承，所以不需要传入参数
phone.charging(new VoltageAdapter());
}
}
9.2.2 类适配器注意事项
- Java 是单继承机制，所以类适配器需要继承 src 类这一点算是一个缺点, 因为这要求 dst 必须是接口，有一定局限性;
- src 类的方法在 Adapter 中都会暴露出来，也增加了使用的成本。
- 由于其继承了 src 类，所以它可以根据需求重写 src 类的方法，使得 Adapter 的灵活性增强了。
9.3 对象适配器
9.3.1 基本介绍
- 基本思路和类的适配器模式相同，只是将 Adapter 类作修改，不是继承 src 类，而是持有 src 类的实例，以解决 兼容性的问题。 即：持有 src 类，实现 dst 类接口，完成 src->dst 的适配
- 根据“合成复用原则”，在系统中尽量使用关联关系（聚合）来替代继承关系。
- 对象适配器模式是适配器模式常用的一种
9.3.2 应用案例
- 场景同上。
- 类图
- 代码实现
（1）被适配类、适配接口、Phone类不变
（2）适配器类
通过构造器实现对象传递。 这个对象是Client中传进来的，而不是通过Voltage220V中的output220V方法得来的。
//适配器类
public class VoltageAdapter implements IVoltage5V {
private Voltage220V voltage220V; // 关联关系-聚合
//通过构造器，传入一个 Voltage220V 实例；
public VoltageAdapter(Voltage220V voltage220v) {
this.voltage220V = voltage220v;
}
@Override
public int output5V() {
int dst = 0;
if(null != voltage220V) {
int src = voltage220V.output220V();//获取220V 电压
System.out.println("使用对象适配器，进行适配~~");
dst = src / 44;
System.out.println("适配完成，输出的电压为=" + dst);
}
return dst;
}
}
（3）客户端类
public class Client {
public static void main(String[] args) {
System.out.println(" === 对象适配器模式 ====");
Phone phone = new Phone();
//因为是聚合关系，所以要传入参数
phone.charging(new VoltageAdapter(new Voltage220V()));
}
}
9.3.3 对象适配器的注意事项
- 对象适配器和类适配器其实算是同一种思想，只不过实现方式不同。
根据合成复用原则，使用组合替代继承， 所以它解决了类适配器必须继承 src 的局限性问题，也不再要求 dst必须是接口。 - 使用成本更低，更灵活。
9.4 接口适配器（缺省适配器）
9.4.1 基本介绍
- 核心思路：当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现（空方法），那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求
- 适用于一个接口不想使用其所有的方法的情况。
9.4.2 应用案例
- 类图
- 代码实现
（1）接口
public interface Interface4 {
public void m1();
public void m2();
public void m3();
public void m4();
}
（2）实现接口的空类
//在AbsAdapter 我们将 Interface4 的方法进行默认实现
public abstract class AbsAdapter implements Interface4 {
//默认实现
public void m1() { }
public void m2() { }
public void m3() { }
public void m4() { }
}
（3）有选择的实现自己需要的类
public class Client {
public static void main(String[] args) {
AbsAdapter absAdapter = new AbsAdapter() {
//只需要去覆盖我们 需要使用 接口方法
@Override
public void m1() {
// TODO Auto-generated method stub
System.out.println("使用了m1的方法");
}
};
absAdapter.m1();
}
}
9.5 适配器模式的注意事项和细节
- 三种命名方式，是根据 src 是以怎样的形式给到 Adapter（在 Adapter 里的形式）来命名的。
- 类适配器：以类给到，在 Adapter 里，就是将 src 当做类，继承
对象适配器：以对象给到，在 Adapter 里，将 src 作为一个对象，持有
接口适配器：以接口给到，在 Adapter 里，将 src 作为一个接口，实现 - Adapter 模式最大的作用还是将原本不兼容的接口融合在一起工作。
- 实际开发中，实现起来不拘泥于我们讲解的三种经典形式
第十章 桥接模式
10.1 手机操作问题
- 现在对不同手机类型的不同品牌实现操作编程(比如:开机、关机、上网，打电话等)，如图:
- 传统方案解决手机操作问题
传统方法对应的类图
- 传统方案解决手机操作问题分析
（1）扩展性问题(类爆炸)，如果我们再增加手机的样式(旋转式)，就需要增加各个品牌手机的类，同样如果我们增加一个手机品牌，也要在各个手机样式类下增加。
（2） 违反了单一职责原则，当我们增加手机样式时，要同时增加所有品牌的手机，这样增加了代码维护成本.
（3）解决方案-使用桥接模式
10.2 桥接模式
- 基本介绍
（1）桥接模式(Bridge 模式)是指：将实现与抽象放在两个不同的类层次中，使两个层次可以独立改变。
（2）是一种结构型设计模式
（3）Bridge 模式基于类的最小设计原则，通过使用封装、聚合及继承等行为让不同的类承担不同的职责。它的主要特点是把抽象(Abstraction)与行为实现(Implementation)分离开来，从而可以保持各部分的独立性以及应对他们的功能扩展 - 类图
说明
（1）Client 类：桥接模式的调用者
（2）抽象类(Abstraction) :维护了 Implementor / 即它的实现类 ConcreteImplementorA…, 二者是聚合关系, Abstraction充当桥接类
（3）RefinedAbstraction : 是 Abstraction 抽象类的子类
（4） Implementor : 行为实现类的接口
（5）ConcreteImplementorA /B ：行为的具体实现类 - 从 UML 图：这里的抽象类和接口是聚合的关系，其实调用和被调用关系
10.3 桥接模式解决手机操作问题
- 类图
- 代码实现
（1）brand接口
//接口
public interface Brand {
void open();
void close();
void call();
}
（2）手机实现类，此类实现品牌接口
public class XiaoMi implements Brand {
@Override
public void open() {
System.out.println(" 小米手机开机 ");
}
@Override
public void close() {
System.out.println(" 小米手机关机 ");
}
@Override
public void call() {
System.out.println(" 小米手机打电话 ");
}
}
（3）抽象手机类
public abstract class Phone {
//组合品牌
private Brand brand;
//构造器
public Phone(Brand brand) {
super();
this.brand = brand;
}
protected void open() {
this.brand.open();
}
protected void close() {
brand.close();
}
protected void call() {
brand.call();
}
}
（4）抽象类的具体实现
//折叠式手机类，继承 抽象类 Phone
public class FoldedPhone extends Phone {
//构造器
public FoldedPhone(Brand brand) {
super(brand);
}
public void open() {
super.open();
System.out.println(" 折叠样式手机 ");
}
public void close() {
super.close();
System.out.println(" 折叠样式手机 ");
}
public void call() {
super.call();
System.out.println(" 折叠样式手机 ");
}
}
（5）客户端
public class Client {
public static void main(String[] args) {
//获取折叠式手机 (样式 + 品牌 )
Phone phone1 = new FoldedPhone(new XiaoMi());
phone1.open();
phone1.call();
phone1.close();
System.out.println("=======================");
Phone phone2 = new FoldedPhone(new Vivo());
phone2.open();
phone2.call();
phone2.close();
}
}
10.4 桥接模式在 JDBC 的源码剖析
- Jdbc 的 Driver 接口，如果从桥接模式来看，Driver 就是一个接口，下面可以有 MySQL 的 Driver，Oracle 的Driver，这些就可以当做实现接口类 。
- 桥接模式的类图
10.5 桥接模式的注意事项
- 注意事项
（1） 实现了抽象和实现部分的分离，从而极大的提供了系统的灵活性，让抽象部分和实现部分独立开来，这有助于系统进行分层设计，从而产生更好的结构化系统。
（2）对于系统的高层部分，只需要知道抽象部分和实现部分的接口就可以了，其它的部分由具体业务来完成。
（3） 桥接模式替代多层继承方案，可以减少子类的个数，降低系统的管理和维护成本。
（4） 桥接模式的引入增加了系统的理解和设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计和编程
（5）桥接模式要求正确识别出系统中两个独立变化的维度(抽象、和实现)，因此其使用范围有一定的局限性，即需要有这样的应用场景。 - 桥接模式其它应用场景
（1）JDBC 驱动程序
（2）银行转账系统
– 转账分类: 网上转账，柜台转账，AMT 转账
– 转账用户类型：普通用户，银卡用户，金卡用户…
（3）消息管理
消息类型：即时消息，延时消息
消息分类：手机短信，邮件消息，QQ 消息…
第十一章 装饰者设计模式
11.1 星巴克咖啡订单项目（咖啡馆）
- 咖啡种类/单品咖啡：Espresso(意大利浓咖啡)、ShortBlack、LongBlack(美式咖啡)、Decaf(无因咖啡)
- 调料：Milk、Soy(豆浆)、Chocolate
- 要求在扩展新的咖啡种类时，具有良好的扩展性、改动方便、维护方便
- 使用 OO 的来计算不同种类咖啡的费用: 客户可以点单品咖啡，也可以单品咖啡+调料组合。
11.2 传统方案
- 方案 1-解决星巴克咖啡订单项目
（1）Drink 是一个抽象类，表示饮料
（2）des 就是对咖啡的描述, 比如咖啡的名字
（3）cost() 方法就是计算费用，Drink 类中做成一个抽象方法.
（4）Decaf 就是单品咖啡， 继承 Drink, 并实现 cost
（5）Espress && Milk 就是单品咖啡+调料， 这个组合很多 - 方案 1问题分析
这样设计，会有很多类，当我们增加一个单品咖啡，或者一个新的调料，类的数量就会倍增，就会出现
类爆炸 - 方案 2-解决星巴克咖啡订单(好点)
方案 1 因为咖啡单品+调料组合会造成类的倍增，因此可以做改进，将调料内置到 Drink 类，这 样就不会造成类数量过多。从而提高项目的维护性(如图)
（1）如图“1区”将调料内置到Drink中，当新建类继承了Drink类后，就继承了调料。
（2）如图“2区”，通过has方法返回调料的多少（boolean或者int类型代表有无或数量）。 - 方案 2 问题分析
（1）方案 2 可以控制类的数量，不至于造成很多的类
（2）在增加或者删除调料种类时，代码的维护量很大
（3）考虑到用户可以添加多份 调料时，可以将 hasMilk 返回一个对应 int
11.3 装饰者模式
- 定义
（1）装饰者模式：动态的将新功能附加到对象上。在对象功能扩展方面，它比继承更有弹性，装饰者模式也体现了 开闭原则(ocp)
（2）这里提到的动态的将新功能附加到对象和 ocp 原则，在后面的应用实例上会以代码的形式体现， - 原理
（1）Component 主体：比如类似前面的 Drink
（2）ConcreteComponent 和 Decorator ConcreteComponent：具体的主体，比如前面的各个单品咖啡
（3）Decorator: 装饰者，比如各调料. - 类图
在如图的 Component 与 ConcreteComponent 之间，如果 ConcreteComponent 类很多,还可以设计一个缓冲层，将共有的部分提取出来，抽象层一个类。
11.4 装饰者模式解决星巴克咖啡订单
- 装饰者模式下的订单：2分巧克力——1份牛奶的LongBlank
（1）Milk包含了LongBlack
（2）一份Chocolate包含了(Milk+LongBlack)
（3）一份Chocolate包含了(Chocolate+Milk+LongBlack)
（4）这样不管是什么形式的单品咖啡+调料组合，通过递归方式可以方便的组合和维护。 - 代码实现
（1）Drink类
public abstract class Drink {
public String des; // 描述
private float price = 0.0f;
public String getDes() {
return des;
}
public void setDes(String des) {
this.des = des;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
//计算费用的抽象方法
//子类来实现
public abstract float cost();
}
（2）coffee类
public class Coffee extends Drink {
@Override
public float cost() {
return super.getPrice();
}
}
（3）单品咖啡类：Espresso类
public class Espresso extends Coffee {
public Espresso() {
setDes(" 意大利咖啡 ");
setPrice(6.0f);
}
}
LongBlack。ShortBlack类似
（4）装饰者类：Decorator
public class Decorator extends Drink {
private Drink obj;
public Decorator(Drink obj) { //组合
this.obj = obj;
}
@Override
public float cost() {
// getPrice 自己价格
return super.getPrice() + obj.cost();
}
@Override
public String getDes() {
// obj.getDes() 输出被装饰者的信息
return des + " " + getPrice() + " && " + obj.getDes();
}
}
（5）调料类：Milk类
具体的Decorator， 这里就是调味品
public class Milk extends Decorator {
public Milk(Drink obj) {
super(obj);
setDes(" 牛奶 ");
setPrice(2.0f); //调味品价格
}
}
Chocolate类、Soy类类似。
（6）客户端
public class CoffeeBar {
public static void main(String[] args) {
// 装饰者模式下的订单：2份巧克力+一份牛奶的LongBlack
// 1. 点一份 LongBlack
Drink order = new LongBlack();
System.out.println("费用1=" + order.cost());
System.out.println("描述=" + order.getDes());
// 2. order 加入一份牛奶
order = new Milk(order);
System.out.println("order 加入一份牛奶 费用 =" + order.cost());
System.out.println("order 加入一份牛奶 描述 = " + order.getDes());
// 3. order 加入一份巧克力
order = new Chocolate(order);
System.out.println("order 加入一份牛奶 加入一份巧克力 费用 =" + order.cost());
System.out.println("order 加入一份牛奶 加入一份巧克力 描述 = " + order.getDes());
// 3. order 加入一份巧克力
order = new Chocolate(order);
System.out.println("order 加入一份牛奶 加入2份巧克力 费用 =" + order.cost());
System.out.println("order 加入一份牛奶 加入2份巧克力 描述 = " + order.getDes());
Drink order2 = new DeCaf();
System.out.println("order2 无因咖啡 费用 =" + order2.cost());
System.out.println("order2 无因咖啡 描述 = " + order2.getDes());
order2 = new Milk(order2);
System.out.println("order2 无因咖啡 加入一份牛奶 费用 =" + order2.cost());
System.out.println("order2 无因咖啡 加入一份牛奶 描述 = " + order2.getDes());
}
}
11. 5 装饰者模式在JDK 应用的源码分析
Java 的 IO 结构，FilterInputStream 就是一个装饰者