写在后面

• 记录学习设计模式的笔记
• 进步对设计模式的灵活运用

学习地址

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）模式的定义： 使用共享技术来无效地反对大量细粒度对象的复用 , 它通过共享曾经存在的对象来大幅度缩小须要创立的对象数量、防止大量类似类的开销，从而进步系统资源的利用率。

享元模式的次要长处是：雷同对象只有保留一份，这升高了零碎中对象的数量，从而升高了零碎中细粒度对象给内存带来的压力。

其次要毛病是：

1. 为了使对象能够共享，须要将一些不能共享的状态内部化，这将减少程序的复杂性。
2. 读取享元模式的内部状态会使得运行工夫略微变长。

14.2 享元模式的构造与实现

14.2.1 享元模式的构造

享元（Flyweight）模式中存在以下两种状态：

1. 外部状态，即不会随着环境的扭转而扭转的可共享局部。
2. 内部状态，指随环境扭转而扭转的不能够共享的局部。享元模式的实现要领就是辨别利用中的这两种状态，并将内部状态内部化。

享元模式的次要有以下角色：

• 形象享元角色（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 享元模式的利用场景

当零碎中多处须要同一组信息时，能够把这些信息封装到一个对象中，而后对该对象进行缓存，这样，一个对象就能够提供给多出须要应用的中央，防止大量同一对象的屡次创立，升高大量内存空间的耗费。

享元模式其实是工厂办法模式的一个改良机制，享元模式同样要求创立一个或一组对象，并且就是通过工厂办法模式生成对象的，只不过享元模式为工厂办法模式减少了缓存这一性能。

后面剖析了享元模式的构造与特点，上面剖析它实用的利用场景。 享元模式是通过缩小内存中对象的数量来节俭内存空间的 ，所以以下几种情景适宜采纳享元模式。

1. 零碎中存在大量雷同或类似的对象，这些对象消耗大量的内存资源。
2. 大部分的对象能够依照外部状态进行分组，且可将不同局部内部化，这样每一个组只需保留一个外部状态。
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 对象。

写在最初

• 如果我的文章对你有用，请给我点个👍，感激你😊！
• 有问题，欢送在评论区指出！💪