本文通过优化买票的反复流程来阐明享元模式，为了加深对该模式的了解，会以 String 和根本数据类型的包装类对该模式的设计进一步阐明。
读者能够拉取残缺代码到本地进行学习，实现代码均测试通过后上传到码云。
一、引出问题
鉴于小王之前的优质体现，老王决定带小王进来游览一下，但在火车站买票时却陷于了长长的队伍。
老王留神到，每次售票员卖票时都从新走一遍卖票的所有流程，很显著，如果始发地和目的地如果一样的成人票和儿童票是能够复用流程的，如果复用的话就能够大大提高卖票效率。
二、概念和应用
下面所说的复用流程实际上就是享元模式的设计思维，它是构造型设计模式之一，它通过共享数据使得雷同对象在内存中仅创立一个实例，以升高零碎创建对象实例的性能耗费。
享元模式蕴含三个角色：
（1）形象享元 Flyweight 类：享元对象形象基类或接口。
（2）具体享元 ConcreteFlyweight 类：实现形象享元类。
（3）享元工 ctory 类：厂 FlyweightFa 享元模式的外围模块，负责管理享元对象池、创立享元对象，保障享元对象能够被零碎适当地共享。
当一个客户端对象调用一个享元对象的时候，享元工厂角色会查看零碎中是否曾经有一个符合要求的享元对象，如果已有，享元工厂角色就提供这个已有的享元对象；如果没有就创立一个。
老王基于享元模式开发了一套卖票零碎，如果终点和起点一样，成人票和儿童票就能够复用一套流程。
形象享元类：
/**
* 形象享元类
*/
public interface Ticket {
// 显示票价，参数为列车类型
public void showPrice(String type);
}具体享元实现类：
/**
* 享元实现类
* @author tcy
* @Date 11-08-2022
*/
public class ConcreteTicket implements Ticket{
String from;
String to;
public ConcreteTicket(String from,String to){
this.from = from;
this.to = to;
}
@Override
public void showPrice(String type) {if(type.equals("adult")){System.out.println("从"+from+"到"+to+"的成人票价为 200 元");
}else{System.out.println("从"+from+"到"+to+"的儿童票价为 100 元");
}
}
}享元工厂类：
/**
* 享元工厂
* @author tcy
* @Date 11-08-2022
*/
public class TicketFactory {static Map<String,Ticket> map= new ConcurrentHashMap< String,Ticket >();
public static Ticket getTicket(String from,String to){
String key = from+to;
if(map.containsKey(key)){System.out.println("应用缓存"+key);
return map.get(key);
}else{System.out.println("创建对象"+key);
Ticket ticket = new ConcreteTicket(from,to);
map.put(key, ticket);
return ticket;
}
}
}客户端调用：
/**
* @author tcy
* @Date 11-08-2022
*/
public class Client {public static void main(String[] args) {
// 应用时
TicketFactory.getTicket("南京","杭州").showPrice("adult");
TicketFactory.getTicket("南京","杭州").showPrice("children");
}
}下面例子是享元模式实现的典型案例。外围其实就是享元工厂类，享元工厂类设置一个缓存池，依据条件判断是否属于一个对象，如果是一个对象就不再从新创立，间接应用缓存池中的。
三、使用
1、jdk 中的 String 就是典型的采纳的享元模式的思维。
Java 中将 String 类定义为 final（不可扭转的），JVM 中字符串个别保留在字符串常量池中，java 会确保一个字符串在常量池中只有一个拷贝，这个字符串常量池在 JDK6.0 以前是位于常量池中，位于永恒代，而在 JDK7.0 中，JVM 将其从永恒代拿进去搁置于堆中。
创立一个字符串有两种形式，一种是间接 String=”hello”，另外一种是 String s =new String(“hello”)，第一种是间接在字符串常量池申明一个变量，第二种形式除了是一个堆中的一般对象以外，还会在字符串常量池保留一份。
咱们常常应用的一些根本数据类型的包装类实际上也应用了享元模式。咱们以 Integer 举例，其余包装类相似。
当咱们申明一个变量时，应用 Integer i1 = 88，编译器是不会报错的，在这 Java 下面的一个概念就叫主动装箱，编译器会主动 应用 valueOf() 办法创立一个 Integer 对象并把值赋给该对象。
查看 valueOf() 办法，如下：
public static Integer valueOf(int i) {if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}Integer 应用享元模式的外围就在于 IntegerCache，它是 Integer 的一个外部类。
这里的 IntegerCache 相当于享元设计模式中的享元对象工厂类，既然是享元对象工厂类就肯定会有断定一个对象是否一样的条件。
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
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) {// If the property cannot be parsed into an int, ignore it.}
}
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() {}
}通过源码咱们能够看到，IntegerCache 的断定一个对象是否是同一个的判断规范就是，一个字节的大小（-128 到 127 之间的数据）都作为一个对象。
既然说到了主动装箱，那绝对应的也肯定会有主动拆箱。
当把包装器类型的变量 i1，赋值给根本数据类型变量 j 的时候，触发主动拆箱操作，将 i1 中的数据取出，赋值给 j，这就是主动拆箱的过程。
其余包装器类型，比方 Long、Short、Byte 等，也都利用了享元模式来缓存 -128 到 127 之间的数据。比方，Long 类型对应的 LongCache 享元工厂类。
四、总结
享元模式与咱们常说的缓存的概念很类似，总体来说还是一个很简略的设计模式，在咱们理论应用中为了进步对象利用率，能够无意识的应用这种模式。
到这里，设计模式的第二个大家族 - 构造形设计模式就介绍完了，万丈高楼平地起，若想灵便的应用设计模式，大量的思考和使用是必不可少的。
举荐读者，参考软件设计七大准则 认真浏览往期的文章，认真领会。
创立型设计模式 ：
一、设计模式之工厂办法和形象工厂
二、设计模式之单例和原型
三、设计模式之建造者模式
结构型设计模式 ：
四、设计模式之代理模式
五、设计模式之适配器模式
六、设计模式之桥接模式
七、设计模式之组合模式
八、设计模式之外观模式