一.代理模式
二.适配器模式
三.装饰者模式
四.桥接模式
五.外观模式
六.组合模式
七.享元模式
注:学习视频:黑马程序员Java设计模式
结构性模式描述如何将类或对象按照某种布局组成撑大的结构,它分为类结构型模式和对象结构型模式,前者是采用继承机制来实现,后者采用组合或聚合的方式来实现。
由于某些原因,需提供一个代理对象来控制对目标对象的访问,或者访问对象不能暴露给调用者直接调用,代理对象就可以作为中介,客户可以通过代理对象来调用目标对象,就像买房的时候,不是直接找到房屋开发商,而是找房屋中介买房。
代理(Proxy)模式分为三大角色:
这里就采用买房子来演示这个案例,房屋开发商作为真实主题类,房屋中介作为代理类,声明一个抽象主题类,让真实主题类和代理类实现接口方法。
代码实现如下:
// 抽象主题类
public interface SellHouse {
void sellHouse();
}
// 房屋开发商(真实主题类)
public class HouseDeveloper implements SellHouse {
public void sellHouse() {
System.out.println("卖房子");
}
}
// 中介(代理类)
public class HouseAgent implements SellHouse{
// 声明一个真实主题类
private HouseDeveloper houseDeveloper = new HouseDeveloper();
public void sellHouse() {
// 对真实主题类增强,也就是作为中介从中收取一点费用
System.out.println("中介卖房子收取费用");
houseDeveloper.sellHouse();
}
}
// 测试类
public class Client {
public static void main(String[] args) {
// 声明一个代理类
HouseAgent houseAgent = new HouseAgent();
houseAgent.sellHouse();
}
}
// 测试结果
中介卖房子收取费用 // 代理类增强部分
卖房子 // 调用仍然是调用真实主题类
说明:
根据上面代码可以看出,真实主题类(HouseDeveloper)和代理类(HouseAgent)都实现了抽象主题类(SellHouse),代理类最终调用的还是真实主题类中的方法,代理类只是帮助调用和增强。
动态代理不是自己创建类,采用jdk动态代理方式实现,是jdk内存中帮助我们创建,我们可以采用工厂来获取这个创建好的代理对象,这个方式实现必须要有抽象主题类。
代码如下:
// 抽象主题类
public interface SellHouse {
void sellHouse();
}
// 房屋开发商(真实主题类)
public class HouseDeveloper implements SellHouse {
public void sellHouse() {
System.out.println("房屋开发商卖房子");
}
}
// 代理工厂
public class ProxyFactory {
// 声明一个真实主题类,给代理类调用
private HouseDeveloper houseDeveloper = new HouseDeveloper();
// 返回值是抽象主题类或抽象接口
public SellHouse getProxyInstance(){
// 创建一个代理对象 以下三个参数
/**
* ClassLoader loader : 真是主题类的类加载器
* Class>[] interfaces : 真是主题类实现的接口字节码
* InvocationHandler h : 代理类处理对象,最后代理类的处理方法将会在这里执行
*/
SellHouse houseAgent = (SellHouse) Proxy.newProxyInstance(houseDeveloper.getClass().getClassLoader(),
houseDeveloper.getClass().getInterfaces(),
new InvocationHandler() {
/**
*
* @param proxy 就是当前创建的代理对象
* @param method 代理对象中的代理方法,因为采用反射调用,所有任何真是主题类方法,都在这里调用
* @param args 调用真是主题类所需的参数
* @return 调用真是主题类的返回值
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 代理类增强
System.out.println("房屋中介卖房子收取费用");
// 反射调用真是主题类方法
Object obj = method.invoke(houseDeveloper, args);
return obj;
}
});
return houseAgent;
}
}
// 测试类
public class Client {
public static void main(String[] args) {
// 通过代理工厂类获取代理类
SellHouse houseAgent = new ProxyFactory().getProxyInstance();
// 调用方法
houseAgent.sellHouse();
}
}
// 测试结果
房屋中介卖房子收取费用 // 调用了invoke方法
房屋开发商卖房子
说明:
采用jdk动态代理方式必须要有抽象主题类,采用反射实现方法的调用,可以将抽象主题类中的方法全部聚合到一个方法
invoke
中处理。
动态代理底层创建的代理对象代码(删减):
public final class $Proxy0 extends Proxy implements SellHouse {
private static Method m3;
public $Proxy0(InvocationHandler invocationHandler) {
super(invocationHandler);
}
static {
m3 = Class.forName("com.itheima.proxy.dynamic.jdk.SellHouse").getMethod("sell", new Class[0]);
}
public final void sell() {
this.h.invoke(this, m3, null);
}
}
执行流程:
1. 在测试类中通过代理对象调用sell()方法
2. 根据多态的特性,执行的是代理类($Proxy0)中的sell()方法
3. 代理类($Proxy0)中的sell()方法中又调用了InvocationHandler接口的子实现类对象的invoke方法
4. invoke方法通过反射执行了真实对象所属类(HouseDeveloper)中的sell()方法
如果没有抽象主题类,我们就可以采用Cglib来实现动态代理。
Cglib是第三方的包,引入以下依赖:
<dependency>
<groupId>cglibgroupId>
<artifactId>cglibartifactId>
<version>3.3.0version>
dependency>
代码如下:
// 房屋开发商(真实主题类)
public class HouseDeveloper implements SellHouse {
public void sellHouse() {
System.out.println("房屋开发商卖房子");
}
}
// 代理工厂类
public class ProxyFactory implements MethodInterceptor {
private HouseDeveloper houseDeveloper = new HouseDeveloper();
public HouseDeveloper getProxyObj(){
// 创建一个enhancer对象,类似于JDK实现中的Proxy
Enhancer enhancer = new Enhancer();
// 设置真实主题类的字节码对象,cglib是继承真实主题类实现的,所以要设置父类字节码
enhancer.setSuperclass(houseDeveloper.getClass());
// 设置回调函数,将自己作为回调函数,回调函数类似于JDK里面的Invoke
// 需要实现MethodInterceptor接口
enhancer.setCallback(this);
// 生成代理对象返回
HouseDeveloper houseAgent = (HouseDeveloper) enhancer.create();
return houseAgent;
}
/**
* 代理对象的具体增强方法
* @param obj
* @param method
* @param args
* @param proxy
* @return
* @throws Throwable
*/
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
// 代理对象增强
System.out.println("房屋中介卖房子收取费用");
// 反射调用方法
Object result = method.invoke(houseDeveloper, args);
return result;
}
}
// 测试类
public class Client {
public static void main(String[] args) {
HouseDeveloper houseAgent = new ProxyFactory().getProxyObj();
houseAgent.sellHouse();
}
}
// 测试结果
房屋中介卖房子收取费用 // 调用了intercept方法
房屋开发商卖房子
使用cglib实现动态代理,底层采用ASM字节码生成框架,使用字节码技术生成代理类,在Jdk1.6之前比Jdk实现速度快,不需要抽象主题类就可以实现。
在Jdk1.8优化以后,性能已经高于Cglib,需要有抽象主题类的才能实现.
动态代理与静态代理相比较,最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理(InvocationHandler.invoke)。这样,在接口方法数量比较多的时候,我们可以进行灵活处理,而不需要像静态代理那样每一个方法进行中转。
如果接口增加一个方法,静态代理模式除了所有实现类需要实现这个方法外,所有代理类也需要实现此方法。增加了代码维护的复杂度。而动态代理不会出现该问题
优点:
缺点:
本地服务通过网络请求远程服务。为了实现本地到远程的通信,我们需要实现网络通信,处理其中可能的异常。为良好的代码设计和可维护性,我们将网络通信部分隐藏起来,只暴露给本地服务一个接口,通过该接口即可访问远程服务提供的功能,而不必过多关心通信部分的细节。
当你将浏览器配置成使用代理功能时,防火墙就将你的浏览器的请求转给互联网;当互联网返回响应时,代理服务器再把它转给你的浏览器。
控制对一个对象的访问,如果需要,可以给不同的用户提供不同级别的使用权限。
将一个类的接口装换为客户希望的另一个接口,使原本由于接口不兼容而不能一起工作的类能够一起工作。
实现方式:
定义一个适配器类,通过继承适配者类,同时实现目标接口的方法。实现的方法体内调用继承过来的方法,实现适配者类转换为目标接口类。
【例】读卡器
现在有一台电
脑只能读取SD卡,如果需要读取TF卡的话,就需要使用适配器模式了,创建一个读卡器,将TF中的内容读取出来返回。
类图:
代码如下:
/**
* SD卡接口类(目标接口)
*/
public interface SDCard {
// 从sd卡中读取数据
String read();
// 写入sd卡
void write(String msg);
}
/**
* 目标接口实现类
*/
public class SDCardImpl implements SDCard{
@Override
public String read() {
String msg = "SD card read msg : hello word SD";
return msg;
}
@Override
public void write(String msg) {
System.out.println("SD card write msg : " + msg);
}
}
/**
* 适配者类
*/
public interface TFCard {
// 从TF卡中读取数据
String read();
// 写入TF卡
void write(String msg);
}
/**
* 适配者类实现类
*/
public class TFCardImpl implements TFCard{
@Override
public String read() {
String msg = "TF card read msg : hello word TF";
return msg;
}
@Override
public void write(String msg) {
System.out.println("TF card write msg : " + msg);
}
}
/**
* 类适配器类,继承TF实现类,实现 SDCard 接口
*/
public class SDAdapterTF extends TFCardImpl implements SDCard {
@Override
public String read() {
return super.read();
}
@Override
public void write(String msg) {
super.write(msg);
}
}
/**
* 计算机类
*/
public class Computer {
// 目标接口类,这里直接接受SDCard的子实现类,TFCard不能传入
private SDCard sdCard;
public Computer(SDCard sdCard){
this.sdCard = sdCard;
}
// 读取SDCard方法
public void read(){
System.out.println(sdCard.read());
}
}
// 测试类
public class Client {
public static void main(String[] args) {
// 创建计算机对象,传入 SDCard 的实现类
Computer computer = new Computer(new SDCardImpl());
// 调用计算机读取SD卡内容
computer.read();
System.out.println("=================================");
// 用适配器类作为目标接口传入
Computer computer1 = new Computer(new SDAdapterTF());
computer1.read();
}
}
// 测试结果
SD card read msg : hello word SD
=================================
TF card read msg : hello word TF
对象适配器模式,只需在类适配器的基础上修改即可,将继承 适配者类实现类(TFCardImpl) 变成聚合适配者类实现类(TFCardImpl)。
代码如下:
/**
* 类适配器类,继承TF实现类,实现 SDCard 接口
*/
public class SDAdapterTF implements SDCard {
private TFCard tfCard;
public SDAdapterTF(TFCard tfCard){
this.tfCard =tfCard;
}
@Override
public String read() {
return tfCard.read();
}
@Override
public void write(String msg) {
tfCard.write(msg);
}
}
// 测试类
public class Client {
public static void main(String[] args) {
// 创建计算机对象,传入 SDCard 的实现类
Computer computer = new Computer(new SDCardImpl());
// 调用计算机读取SD卡内容
computer.read();
System.out.println("=================================");
// 用适配器类作为目标接口传入
Computer computer1 = new Computer(new SDAdapterTF(new TFCardImpl()));
computer1.read();
}
}
//测试结果
SD card read msg : hello word SD
=================================
TF card read msg : hello word TF
说明:
还有一个适配器模式是接口适配器模式,可以通过同时是实现适配者接口和目标接口,来实现适配器。
Reader(字符流)、InputStream(字节流)的适配使用的是InputStreamReader。
结论:
Reader是读取字符流的接口,也就是目标接口,而InputStream是读取字节流的实现类,而StreamDecoder就是适配器,就是引用了InputStream和实现了Reader接口,典型的对象适配器模式。
一个快餐店的例子,快餐店里面有炒饭、炒面,炒饭和炒面都可以加配料鸡蛋、培根。计算总价一般都不一样的。
使用继承实现存在的问题:
如果要再加入一种配料,就需要创建所有的产品都添加该配料的实现类,可能会造成类爆炸
定义:
指在不改变对象结构的情况下,动态地给该对象增加一些职责(即增加而外的功能)和模式。
装饰者模式(Decorator)的角色如下:
采用装饰者类来是实现快餐店案例
具体实现过程:
类图如下:
代码如下:
/**
* 快餐类 (抽象装饰部件角色)
*/
public abstract class FastFood {
// 价格
private double price;
// 描述
private String desc;
public FastFood() {
}
// 提供构造方法
public FastFood(double price, String desc) {
this.price = price;
this.desc = desc;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
// 定义一个抽象方法,计算价格由子类来实现
public abstract double cost();
}
/**
* 炒饭类(具体装饰角色)
*/
public class FireRice extends FastFood {
public FireRice() {
super(10, "炒饭");
}
// 重写方法,返回炒饭的价格
@Override
public double cost() {
return getPrice();
}
}
/**
* 炒面(具体装饰构件角色)
*/
public class FireNoodles extends FastFood{
public FireNoodles() {
super(12,"炒面");
}
@Override
public double cost() {
return super.getPrice();
}
}
/**
* 配料类 (抽象装饰角色)
* 继承并聚合抽象装饰者角色FastFood
*/
public class Garnish extends FastFood{
// 聚合抽象装饰者角色,给具体装饰者类来使用
private FastFood fastFood;
public Garnish(FastFood fastFood,double price,String desc) {
super(price,desc);
this.fastFood = fastFood;
}
@Override
public double cost() {
return getPrice();
}
public FastFood getFastFood() {
return fastFood;
}
public void setFastFood(FastFood fastFood) {
this.fastFood = fastFood;
}
}
/**
* 鸡蛋配料类(具体装饰角色)
*/
public class Egg extends Garnish{
public Egg(FastFood fastFood) {
super(fastFood, 1, "鸡蛋");
}
@Override
public double cost() {
return super.cost() + super.getFastFood().cost();
}
@Override
public String getDesc() {
return super.getDesc() + super.getFastFood().getDesc();
}
}
/**
* 具体装饰角色
*/
public class Bacon extends Garnish{
public Bacon(FastFood fastFood) {
super(fastFood, 2, "培根");
}
@Override
public double cost() {
return super.cost() + super.getFastFood().cost();
}
@Override
public String getDesc() {
return super.getDesc() + super.getFastFood().getDesc();
}
}
// 测试类
public class Client {
public static void main(String[] args) {
// 创建普通炒面对象
FastFood food = new FireNoodles();
// 输出描述和价格
System.out.println(food.getDesc() + " " + food.cost());
System.out.println("===========添加鸡蛋配料后==============");
food = new Egg(food);
System.out.println(food.getDesc() + " " + food.cost());
System.out.println("===========添加培根配料后==============");
food = new Bacon(food);
System.out.println(food.getDesc() + " " + food.cost());
}
}
// 测试结果
炒面 12.0
===========添加鸡蛋配料后==============
鸡蛋炒面 13.0
===========添加培根配料后==============
培根鸡蛋炒面 15.0
说明:
装饰者模式是在不修改原来组件的情况下,增加组件的功能,装饰类和被装饰类都有独立发张,不会相互耦合,装饰模式是继承的一个代替模式,装饰模式可以动态的扩展一个是实现类的功能。
当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展和维护时。
不能采用继承的情况主要有两类:
在不影响其他对象的情况下,以动态、透明的方式给单个对象添加职责。
IO流中的包装类使用到了装饰者模式。BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedWriter。
我们以BufferedWriter举例来说明,先看看如何使用BufferedWriter
public class Demo {
public static void main(String[] args) throws Exception{
//创建BufferedWriter对象
//创建FileWriter对象
FileWriter fw = new FileWriter("C:\\Users\\Think\\Desktop\\a.txt");
// 这里的BufferWriter就是装饰者类,具体装饰部件FileWriter进行功能扩展,使其实现了缓存。
BufferedWriter bw = new BufferedWriter(fw);
//写数据
bw.write("hello Buffered");
bw.close();
}
}
类图:
这里的BufferWriter就是装饰者类,具体装饰部件FileWriter进行功能扩展,使其实现了缓存。
静态代理和装饰着的区别:
现有一个需求,首先我们需要绘制不同的图形,其次,我们不同的图形有不同的颜色。
为改进类图:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wPpnAFCV-1650622192123)(C:/Users/安逸i/Desktop/Course Notes/java/Design mode/img/image-20200207194617620.png)]
从上图中可以看出, 这个构建方式需要使用两层的继承关系,并且类的数量非常大。如果需要增加一中形状的图形的话,那么就需要再增加它的三个子类,这样的话,容易造成类爆炸。
所以我们就可以将其中的一个维度进行桥接扩展
定义:
将抽象与实现分离,使它们可以独立的变化,它使用组合关系代替继承关系来实现,从而降低了抽象和实现这两个可变维度的耦合性。
桥接(Bridge)模式包括以下角色:
就以上面的绘图作为案例,改进成桥接模式
具体实现过程:
代码如下:
/**
* 图形类(抽象化角色)
*/
public abstract class Shape {
// 引用/聚合实现化角色
private ShapeColor shapeColor;
private String name;
public Shape(ShapeColor shapeColor, String name) {
this.shapeColor = shapeColor;
this.name = name;
}
// 定义一个画图方法由子类(扩展化角色来实现)
abstract void draw();
public ShapeColor getShapeColor() {
return shapeColor;
}
public void setShapeColor(ShapeColor shapeColor) {
this.shapeColor = shapeColor;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
/**
* 绘制线的扩展类
*/
public class LineShape extends Shape{
public LineShape(ShapeColor shapeColor) {
super(shapeColor, "线");
}
@Override
void draw() {
System.out.println(getShapeColor().drawColor() + getName());
}
}
/**
* 圆形(扩展类对象)
*/
public class RoundShape extends Shape{
public RoundShape(ShapeColor shapeColor) {
super(shapeColor, "圆");
}
@Override
void draw() {
System.out.println(getShapeColor().drawColor() + getName());
}
}
/**
* 图形颜色(实现化角色)
*/
public interface ShapeColor {
String drawColor();
}
/**
* 绿色的(具体实现化类)
*/
public class GreenShapeColor implements ShapeColor{
@Override
public String drawColor() {
return "绿";
}
}
/**
* 红色(具体实现化类)
*/
public class RedShapeColor implements ShapeColor{
@Override
public String drawColor() {
return "红";
}
}
// 测试类
public class Client {
public static void main(String[] args) {
GreenShapeColor greenShapeColor = new GreenShapeColor();
RedShapeColor redShapeColor = new RedShapeColor();
LineShape greenLine = new LineShape(greenShapeColor);
RoundShape redRound = new RoundShape(redShapeColor);
greenLine.draw();
redRound.draw();
}
}
// 测试结果
绿线
红圆
好处:
桥接模式提高了系统的可扩充性,在两个变化维度中任意扩展一个维度,都不需要修改原有系统。
如:如果现在还有一种视频文件类型wmv,我们只需要再定义一个类实现VideoFile接口即可,其他类不需要发生变化。
实现细节对客户透明
如果你想投资理财,但是你没有经验,往往很容易亏钱,但是你可以将钱交给基金,基金会帮你进行股票、债券、外汇等投资,这里的基金就像是外观模式的外观角色,而投资项目就是子系统,我们只需要跟基金互动,就可以完成投资的操作。
外观(Facade)模式是“迪米特法则”的典型应用:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6T0iearb-1650622192124)(C:/Users/安逸i/Desktop/Course Notes/java/Design mode/img/外观模式引入.jpg)]
外观模式包含一下角色:
智能家电控制
通过外观类来实现多个家电的一键开启和一键关闭。
类图如下:
代码如下:
/**
* 电视类
*/
public class TV {
// 打开电视
public void on(){
System.out.println("电视打开了...");
}
// 关闭电视
public void off(){
System.out.println("电视关闭了...");
}
}
/**
* 灯类
*/
public class Light {
// 打开灯
public void on(){
System.out.println("灯打开了...");
}
// 关闭灯
public void off(){
System.out.println("灯关闭了...");
}
}
/**
* 空调类
*/
public class AirCondition {
// 打开空调
public void on(){
System.out.println("空调打开了...");
}
// 关闭空调
public void off(){
System.out.println("空调关闭了...");
}
}
/**
* 外观类
*/
public class SmartApplicationFacade {
private TV tv;
private Light light;
private AirCondition airCondition;
public SmartApplicationFacade() {
this.tv = new TV();
this.light = new Light();
this.airCondition = new AirCondition();
}
public void on(){
this.tv.on();
this.light.on();
this.airCondition.on();
}
public void off(){
this.tv.off();
this.light.off();
this.airCondition.off();
}
}
/**
* 测试类
*/
public class Client {
public static void main(String[] args) {
SmartApplicationFacade smartApplicationFacade = new SmartApplicationFacade();
smartApplicationFacade.on();
System.out.println("=================");
smartApplicationFacade.off();
}
}
// 测试结果
电视打开了...
灯打开了...
空调打开了...
=================
电视关闭了...
灯关闭了...
空调关闭了...
好处:
使用tomcat容器的时候,会发现有两个类 HttpRequest和HttpServletRequest ,而真正接收网络请求的时候request,那么这两个类一定是进行了封装的,而进行封装的正式RequestFacade对象,这个对象就是一个外观对象,它对request进行了封装,对于一些request的方法进行了屏蔽,保证了安全性。
RequestFacade类就使用了外观模式。先看结构图:
为什么在此处使用外观模式呢?
定义 RequestFacade 类,分别实现 ServletRequest ,同时定义私有成员变量 Request ,并且方法的实现调用 Request 的实现。然后,将 RequestFacade上转为 ServletRequest 传给 servlet 的 service 方法,这样即使在 servlet 中被下转为 RequestFacade ,也不能访问私有成员变量对象中的方法。既用了 Request ,又能防止其中方法被不合理的访问。
上图中层级结构是经常能见到的,如果做一个文件系统,这种结构称为树形结构,在树形结构中可以通过调用方法来遍历整个数,树形结构分为树枝结点(容器结点)和叶子结点,因为容器结点和叶子结点属于不同类型的结点,实现的功能也不一样,所以在使用的时候,我们需要区分两个结点,而组合模式就是用来让使用者调对待容器结点和叶子结点能调用同一个接口。
定义:
又称为从部分整体模式,是用于把一组相似的对象当作单一的对象,组合模式依据树形结构来组合对象,用来表示部分以及整体层次,这种设计模式属于结构性模式,它创建了对象组的树形结构。
组合模式主要包含以下三种角色:
如下图,我们在访问别的一些管理系统时,经常可以看到类似的菜单。一个菜单可以包含菜单项(菜单项是指不再包含其他内容的菜单条目),也可以包含带有其他菜单项的菜单,因此使用组合模式描述菜单就很恰当,我们的需求是针对一个菜单,打印出其包含的所有菜单以及菜单项的名称。
类图如下:
实现思路:
代码实现:
/**
* 抽象根节点
*/
public abstract class MenuComponent {
protected String name;
protected Integer level;
public MenuComponent(String name, Integer level) {
this.name = name;
this.level = level;
}
// 添加节点方法,如果不重写,就不支持改方法
public void add(MenuComponent menuComponent){
throw new UnsupportedOperationException("没有该操作");
}
// 删除节点
public void remove(MenuComponent menuComponent){
throw new UnsupportedOperationException("没有该操作");
}
public void getChild(Integer index){
throw new UnsupportedOperationException("没有该操作");
}
// 获取名字
public String getName() {
return name;
}
// 打印名字以及根节点名字
public abstract void print();
}
/**
* 树枝节点类
*/
public class Menu extends MenuComponent {
// 声明子子节点集合
private List<MenuComponent> menuComponentList;
public Menu(String name, Integer level) {
super(name, level);
menuComponentList =new ArrayList<>();
}
// 添加方法
@Override
public void add(MenuComponent menuComponent) {
menuComponentList.add(menuComponent);
}
// 删除方法
@Override
public void remove(MenuComponent menuComponent) {
menuComponentList.remove(menuComponent);
}
// 获取子节点方法
@Override
public void getChild(Integer index) {
menuComponentList.get(index);
}
// 打印节点名字,以及子节点名字
@Override
public void print() {
for (int i = 0; i < level; i++) {
System.out.print("--");
}
// 打印本节点名字
System.out.println(getName());
for (MenuComponent menuComponent : menuComponentList) {
menuComponent.print();
}
}
}
/**
* 叶子节点
*/
public class MenuItem extends MenuComponent{
public MenuItem(String name, Integer level) {
super(name, level);
}
@Override
public void print() {
for (int i = 0; i < level; i++) {
System.out.print("--");
}
System.out.println(getName());
}
}
// 测试类
public class Client {
public static void main(String[] args) {
// 创建二级菜单
Menu menu = new Menu("菜单管理", 2);
// 创建对应的三级菜单
menu.add(new MenuItem("页面访问",3));
menu.add(new MenuItem("展开菜单",3));
menu.add(new MenuItem("编辑菜单",3));
Menu menu1 = new Menu("限权配置", 2);
menu1.add(new MenuItem("页面访问",3));
menu1.add(new MenuItem("提交保存",3));
Menu menu2 = new Menu("角色管理", 2);
menu2.add(new MenuItem("新增角色",3));
menu2.add(new MenuItem("修改角色",3));
// 创建根节点
Menu root = new Menu("系统管理", 1);
root.add(menu);
root.add(menu1);
root.add(menu2);
root.print();
}
}
// 测试结果
--系统管理
----菜单管理
------页面访问
------展开菜单
------编辑菜单
----限权配置
------页面访问
------提交保存
----角色管理
------新增角色
------修改角色
根据组合模式中用于管理成员对象的方法声明位置可以分为透明组合模式和安全组合模式。
透明组合模式中,抽象根节点角色中声明了所有用于管理成员对象的方法,比如在示例中
MenuComponent
声明了add
、remove
、getChild
方法,这样做的好处是确保所有的构件类都有相同的接口。透明组合模式也是组合模式的标准形式。透明组合模式的缺点是不够安全,因为叶子对象和容器对象在本质上是有区别的,叶子对象不可能有下一个层次的对象,即不可能包含成员对象,因此为其提供 add()、remove() 等方法是没有意义的,这在编译阶段不会出错,但在运行阶段如果调用这些方法可能会出错(如果没有提供相应的错误处理代码)
在安全组合模式中,用于管理成员对象的方法声明在具体的叶子节点中,这种方法虽然可以保证安全性,但是已经不算是标准的组合模式了,叶子节点和树枝节点虽然继承了同一个根节点类,但是两个节点所拥有的方法就不一致了,不能看作一个接口。
**可以清楚的表示分层次的复杂对象:**组合模式可以清楚定义分层次的复杂对象,表示全部或部分层次,让客户端忽略层次的差异,方便对整个层次进行控制
**简化客户端代码:**客户端可以一致地使用一个组合结构或其中单个对象,不必关心处理的是单个对象还是整个组合结构,简化了客户端代码。
**符合开闭原则,增加方便:**在组合模式中增加新的树枝节点和叶子节点都很方便,无须对现有类库进行任何修改,符合“开闭原则”。
**可以递归调用,简化控制:**组合模式为树形结构的面向对象实现提供了一种灵活的解决方案,通过叶子节点和树枝节点的递归组合,可以形成复杂的树形结构,但对树形结构的控制却非常简单。
组合模式正是应树形结构而生,所以组合模式的使用场景就是出现树形结构的地方。比如:文件目录显示,多级目录呈现等树形结构数据的操作。
定义:
运用共享技术来有效的支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量,避免大量相似对象的开销,从而提高系统资源的利用率。
享元(Flyweight)模式中存在以下两种状态:
享元模式的主要有以下角色:
下面的图片是众所周知的俄罗斯方块中的一个个方块,如果在俄罗斯方块这个游戏中,每个不同的方块都是一个实例对象,这些对象就要占用很多的内存空间,下面利用享元模式进行实现。
类图如下:
代码如下:
形状属于享元对象,是内部状态,而颜色是外部状态。
俄罗斯方块有不同的形状,我们可以对这些形状向上抽取出AbstractBox,用来定义共性的属性和行为。
public abstract class AbstractBox {
public abstract String getShape();
public void display(String color) {
System.out.println("方块形状:" + this.getShape() + " 颜色:" + color);
}
}
定义不同形状类
// I形状
public class IBox extends AbstractBox {
@Override
public String getShape() {
return "I";
}
}
// L形状
public class LBox extends AbstractBox {
@Override
public String getShape() {
return "L";
}
}
// O形状
public class OBox extends AbstractBox {
@Override
public String getShape() {
return "O";
}
}
抽取出一个工厂类(BoxFactory),用来管理享元对象(也就是抽象享元对象ABstractBox的子类),该工厂类只需要一个,所以结合 饿汉式(静态变量方式)来实现单例。
public class BoxFactory {
private static HashMap<String, AbstractBox> map;
// 初始化享元对象集合,相当于缓存,之后如果需要使用享元对象就从这里面取
private BoxFactory() {
map = new HashMap<String, AbstractBox>();
AbstractBox iBox = new IBox();
AbstractBox lBox = new LBox();
AbstractBox oBox = new OBox();
map.put("I", iBox);
map.put("L", lBox);
map.put("O", oBox);
}
// 单例模式返回对象
public static final BoxFactory getInstance() {
return SingletonHolder.INSTANCE;
}
private static class SingletonHolder {
private static final BoxFactory INSTANCE = new BoxFactory();
}
// 获取享元对象的方法
public AbstractBox getBox(String key) {
return map.get(key);
}
}
测试类
// 测试类
public class Client {
public static void main(String[] args) {
AbstractBox box1= BoxFactory.getInstance.getBox("L");
box1.display("红");
AbstractBox box2= BoxFactory.getInstance.getBox("L");
box1.display("绿");
System.out.println("box1 和 box2 是同一对象吗?" + (box1 == box2));
}
}
// 测试结果
方块形状:L 颜色:红
方块形状:L 颜色:绿
box1 和 box2 是同一对象吗? true
优点:
极大的减少了内存中相似或相同对象的创建
享元模式中的外部状态(上例中的颜色)相对独立,且不影响内部状态
缺点:
Integer类使用了享元模式。我们先看下面的例子:
public class Demo {
public static void main(String[] args) {
Integer i1 = 127;
Integer i2 = 127;
System.out.println("i1和i2对象是否是同一个对象?" + (i1 == i2));
Integer i3 = 128;
Integer i4 = 128;
System.out.println("i3和i4对象是否是同一个对象?" + (i3 == i4));
}
}
为什么第一个输出语句输出的是true,第二个输出语句输出的是false?通过反编译软件进行反编译,代码如下:
public class Demo {
public static void main(String[] args) {
Integer i1 = Integer.valueOf((int)127);
Integer i2 Integer.valueOf((int)127);
System.out.println((String)new StringBuilder().append((String)"i1\u548ci2\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i1 == i2)).toString());
Integer i3 = Integer.valueOf((int)128);
Integer i4 = Integer.valueOf((int)128);
System.out.println((String)new StringBuilder().append((String)"i3\u548ci4\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i3 == i4)).toString());
}
}
上面代码可以看到,直接给Integer类型的变量赋值基本数据类型数据的操作底层使用的是
valueOf()
,所以只需要看该方法即可
public final class Integer extends Number implements Comparable<Integer> {
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
// 在范围内就从缓存中获取
return IntegerCache.cache[i + (-IntegerCache.low)];
// 如果不在范围内就直接new 一个
return new Integer(i);
}
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
}
数据类型数据的操作底层使用的是 valueOf()
,所以只需要看该方法即可
public final class Integer extends Number implements Comparable<Integer> {
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
// 在范围内就从缓存中获取
return IntegerCache.cache[i + (-IntegerCache.low)];
// 如果不在范围内就直接new 一个
return new Integer(i);
}
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
}
可以看到
Integer
默认先创建并缓存-128 ~ 127
之间数的Integer
对象,当调用valueOf
时如果参数在-128 ~ 127
之间则计算下标并从缓存中返回,否则创建一个新的Integer
对象。