这就是享元模式！
- 1. 享元模式概述
- 2. 享元模式的结构与实现
- 3. 享元模式的应用实例
- 4. 有外部状态的享元模式
- 5. 单纯享元模式和复合享元模式
- 6. 享元模式的优缺点与适用环境
“Github：https://github.com/nateshao/design-demo/tree/main/JavaDesignPatterns/14-flyweight
1. 享元模式概述
动机
- 如果一个软件系统在运行时所创建的相同或相似对象数量太多，将导致运行代价过高，带来系统资源浪费、性能下降等问题
- 如何避免系统中出现大量相同或相似的对象，同时又不影响客户端程序通过面向对象的方式对这些对象进行操作呢？
字符享元对象示意图
分析
享元模式：通过共享技术实现相同或相似对象的重用
享元池(Flyweight Pool)：存储共享实例对象的地方
内部状态(Intrinsic State)：存储在享元对象内部并且不会随环境改变而改变的状态，内部状态可以共享（例如：字符的内容）
外部状态(Extrinsic State)：随环境改变而改变的、不可以共享的状态。享元对象的外部状态通常由客户端保存，并在享元对象被创建之后，需要使用的时候再传入到享元对象内部。一个外部状态与另一个外部状态之间是相互独立的（例如：字符的颜色和大小）
原理
(1) 将具有相同内部状态的对象存储在享元池中，享元池中的对象是可以实现共享的
(2) 需要的时候将对象从享元池中取出，即可实现对象的复用
(3) 通过向取出的对象注入不同的外部状态，可以得到一系列相似的对象，而这些对象在内存中实际上只存储一份
定义
“享元模式：运用共享技术有效地支持大量细粒度对象的复用。
对象行为型模式
- 又称为轻量级模式
- 要求能够被共享的对象必须是细粒度对象
享元模式的结构
享元模式包含以下4个角色：
Flyweight（抽象享元类）ConcreteFlyweight（具体享元类）UnsharedConcreteFlyweight（非共享具体享元类）FlyweightFactory（享元工厂类）
2. 享元模式的结构与实现
典型的抽象享元类代码：
public abstract class Flyweight {
public abstract void operation(String extrinsicState);
}
典型的具体享元类代码：
public class ConcreteFlyweight extends Flyweight {
//内部状态intrinsicState作为成员变量，同一个享元对象其内部状态是一致的
private String intrinsicState;
public ConcreteFlyweight(String intrinsicState) {
this.intrinsicState = intrinsicState;
}
//外部状态extrinsicState在使用时由外部设置，不保存在享元对象中，即使是同一个对象，在每一次调用时可以传入不同的外部状态
public void operation(String extrinsicState) {
//实现业务方法
}
}
典型的非共享具体享元类代码：
public class UnsharedConcreteFlyweight extends Flyweight {
public void operation(String extrinsicState) {
//实现业务方法
}
}
典型的享元工厂类代码：
public class FlyweightFactory {
//定义一个HashMap用于存储享元对象，实现享元池
private HashMap flyweights = new HashMap();
public Flyweight getFlyweight(String key) {
//如果对象存在，则直接从享元池获取
if (flyweights.containsKey(key)) {
return (Flyweight)flyweights.get(key);
}
//如果对象不存在，先创建一个新的对象添加到享元池中，然后返回
else {
Flyweight fw = new ConcreteFlyweight();
flyweights.put(key,fw);
return fw;
}
}
}
3. 享元模式的应用实例
“某软件公司要开发一个围棋软件，其界面效果如下图所示：
围棋软件界面效果图
“该软件公司开发人员通过对围棋软件进行分析发现，在图中，围棋棋盘中包含大量的黑子和白子，它们的形状、大小都一模一样，只是出现的位置不同而已。如果将每一个棋子都作为一个独立的对象存储在内存中，将导致该围棋软件在运行时所需内存空间较大，如何降低运行代价、提高系统性能是需要解决的一个问题。为了解决该问题，现使用享元模式来设计该围棋软件的棋子对象。
实例类图
实例代码
IgoChessman：围棋棋子类，充当抽象享元类BlackIgoChessman：黑色棋子类，充当具体享元类WhiteIgoChessman：白色棋子类，充当具体享元类IgoChessmanFactory：围棋棋子工厂类，充当享元工厂类Client：客户端测试类
结果及分析
“在实现享元工厂类时使用了单例模式和简单工厂模式，确保了享元工厂对象的唯一性，并提供了工厂方法向客户端返回享元对象
动机：如何让相同的黑子或者白子能够多次重复显示但位于一个棋盘的不同地方？
- 解决方案：将棋子的位置定义为棋子的一个外部状态，在需要时再进行设置
4. 有外部状态的享元模式
结构：
实现：
public class Coordinates {
private int x;
private int y;
public Coordinates(int x,int y) {
this.x = x;
this.y = y;
}
public int getX() {
return this.x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return this.y;
}
public void setY(int y) {
this.y = y;
}
}
package com.nateshao.flyweight.simple;
/**
* @date Created by 邵桐杰 on 2021/10/23 23:07
* @微信公众号 程序员千羽
* @个人网站 www.nateshao.cn
* @博客 https://nateshao.gitee.io
* @GitHub https://github.com/nateshao
* @Gitee https://gitee.com/nateshao
* Description: 围棋棋子类：抽象享元类
*/
public abstract class IgoChessman {
public abstract String getColor();
public void display() {
System.out.println("棋子颜色：" + this.getColor());
}
}
5. 单纯享元模式和复合享元模式
单纯享元模式
所有的具体享元类都是可以共享的，不存在非共享具体享元类
复合享元模式
将一些单纯享元对象使用组合模式加以组合
“如果希望为多个内部状态不同的享元对象设置相同的外部状态，可以考虑使用复合享元模式
享元模式与String类
public class Demo {
public static void main(String args[]) {
String str1 = "abcd";
String str2 = "abcd";
String str3 = "ab" + "cd";
String str4 = "ab";
str4 += "cd";
System.out.println(str1 == str2);
System.out.println(str1 == str3);
System.out.println(str1 == str4);
str2 += "e";
System.out.println(str1 == str2);
}
}
-------------------------
true
true
false
false
6. 享元模式的优缺点与适用环境
模式优点
- 可以减少内存中对象的数量，使得相同或者相似的对象在内存中只保存一份，从而可以节约系统资源，提高系统性能
- 外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享
模式缺点
- 使得系统变得复杂，需要分离出内部状态和外部状态，这使得程序的逻辑复杂化
- 为了使对象可以共享，享元模式需要将享元对象的部分状态外部化，而读取外部状态将使得运行时间变长
模式适用环境
- 一个系统有大量相同或者相似的对象，造成内存的大量耗费
- 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中
- 在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，在需要多次重复使用享元对象时才值得使用享元模式