写在后面
- 记录学习设计模式的笔记
- 进步对设计模式的灵活运用
学习地址
https://www.bilibili.com/vide…
https://www.bilibili.com/vide…
参考文章
http://c.biancheng.net/view/1…
我的项目源码
https://gitee.com/zhuang-kang/DesignPattern
14,享元模式
14.1 享元模式的定义和特点
享元(Flyweight)模式的定义: 使用共享技术来无效地反对大量细粒度对象的复用 , 它通过共享曾经存在的对象来大幅度缩小须要创立的对象数量、防止大量类似类的开销,从而进步系统资源的利用率。
享元模式的次要长处是:雷同对象只有保留一份,这升高了零碎中对象的数量,从而升高了零碎中细粒度对象给内存带来的压力。
其次要毛病是:
- 为了使对象能够共享,须要将一些不能共享的状态内部化,这将减少程序的复杂性。
- 读取享元模式的内部状态会使得运行工夫略微变长。
14.2 享元模式的构造与实现
14.2.1 享元模式的构造
享元(Flyweight)模式中存在以下两种状态:
- 外部状态,即不会随着环境的扭转而扭转的可共享局部。
- 内部状态,指随环境扭转而扭转的不能够共享的局部。享元模式的实现要领就是辨别利用中的这两种状态,并将内部状态内部化。
享元模式的次要有以下角色:
- 形象享元角色(Flyweight):通常是一个接口或抽象类,在形象享元类中申明了具体享元类公共的办法,这些办法能够向外界提供享元对象的外部数据(外部状态),同时也能够通过这些办法来设置内部数据(内部状态)。
- 具体享元(Concrete Flyweight)角色:它实现了形象享元类,称为享元对象;在具体享元类中为外部状态提供了存储空间。通常咱们能够联合单例模式来设计具体享元类,为每一个具体享元类提供惟一的享元对象。
- 非享元(Unsharable Flyweight) 角色:并不是所有的形象享元类的子类都须要被共享,不能被共享的子类可设计为非共享具体享元类;当须要一个非共享具体享元类的对象时能够间接通过实例化创立。
- 享元工厂(Flyweight Factory)角色:负责创立和治理享元角色。当客户对象申请一个享元对象时,享元工厂检査零碎中是否存在符合要求的享元对象,如果存在则提供给客户;如果不存在的话,则创立一个新的享元对象。
14.2.1 代码实现
关系类图
IBox 定义不同的形态
package com.zhuang.flyweight;
/**
* @Classname IBox
* @Description I 图形类 (具体享元角色)
* @Date 2021/3/25 15:33
* @Created by dell
*/
public class IBox extends AbstractBox {
@Override
public String getShape() {return "I";}
}
LBox 定义不同的形态
package com.zhuang.flyweight;
/**
* @Classname IBox
* @Description L 图形类 (具体享元角色)
* @Date 2021/3/25 15:33
* @Created by dell
*/
public class LBox extends AbstractBox {
@Override
public String getShape() {return "L";}
}
OBox 定义不同的形态
package com.zhuang.flyweight;
/**
* @Classname IBox
* @Description O 图形类 (具体享元角色)
* @Date 2021/3/25 15:33
* @Created by dell
*/
public class OBox extends AbstractBox {
@Override
public String getShape() {return "O";}
}
BoxFactory 提供了一个工厂类(BoxFactory),用来治理享元对象(也就是 AbstractBox 子类对象),该工厂类对象只须要一个,所以能够应用单例模式。并给工厂类提供一个获取形态的办法
package com.zhuang.flyweight;
import java.util.HashMap;
/**
* @Classname BoxFactory
* @Description 工厂类 将类设计为单例模式
* @Date 2021/3/25 15:33
* @Created by dell
*/
public class BoxFactory {
private HashMap<String, AbstractBox> map;
// 在构造方法中初始化
private BoxFactory() {map = new HashMap<String, AbstractBox>();
IBox iBox = new IBox();
LBox lBox = new LBox();
OBox oBox = new OBox();
map.put("I", iBox);
map.put("L", lBox);
map.put("O", oBox);
}
// 申明一个办法获取工厂
public static BoxFactory getInstance() {return SingletonHolder.INSTANCE;}
private static class SingletonHolder {private static final BoxFactory INSTANCE = new BoxFactory();
}
// 依据图形名称获取图形对象
public AbstractBox getShape(String name) {return map.get(name);
}
}
AbstractBox 对这些形态向上抽取出 AbstractBox,用来定义共性的属性和行为
package com.zhuang.flyweight;
/**
* @Classname AbstractBox
* @Description 形象享元角色 抽象类
* @Date 2021/3/25 15:32
* @Created by dell
*/
public abstract class AbstractBox {
// 获取图形的办法
public abstract String getShape();
// 显示图形及色彩
public void display(String color) {System.out.println("方块形态:" + this.getShape() + "色彩:" + color);
}
}
14.3 享元模式的利用场景
当零碎中多处须要同一组信息时,能够把这些信息封装到一个对象中,而后对该对象进行缓存,这样,一个对象就能够提供给多出须要应用的中央,防止大量同一对象的屡次创立,升高大量内存空间的耗费。
享元模式其实是工厂办法模式的一个改良机制,享元模式同样要求创立一个或一组对象,并且就是通过工厂办法模式生成对象的,只不过享元模式为工厂办法模式减少了缓存这一性能。
后面剖析了享元模式的构造与特点,上面剖析它实用的利用场景。 享元模式是通过缩小内存中对象的数量来节俭内存空间的 ,所以以下几种情景适宜采纳享元模式。
- 零碎中存在大量雷同或类似的对象,这些对象消耗大量的内存资源。
- 大部分的对象能够依照外部状态进行分组,且可将不同局部内部化,这样每一个组只需保留一个外部状态。
- 因为享元模式须要额定保护一个保留享元的数据结构,所以该当在有足够多的享元实例时才值得应用享元模式
14.4 JDK 源码解析
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
为什么第一个输入语句输入的是 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)];
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
对象。
写在最初
- 如果我的文章对你有用,请给我点个👍,感激你😊!
- 有问题,欢送在评论区指出!💪