享元模式-提供统一实现对象的复用

 下围棋时，分为黑白棋子。棋子都一样，这是出现的位置不同而已。如果将每个棋子都作为一个独立的对象存储在内存中，将导致内存空间消耗较大。我们可以将其中不变的部分抽取出来，只存储它的位置信息来实现节约内存。

 图 围棋

1 享元模式概述

通过共享技术实现相同或相似对象重用。做到共享的关键是区分“内部状态”和“外部状态”。

1. 内部状态：是存储在享元内部并且不会随着环境改变而改变的状态，内部状态可共享。比如围棋的颜色属性。
2. 外部状态：是随着环境改变而改变的、不可共享的状态。外部状态通常由客户端保存，并且在享元对象被创建之后，需要使用的时候，再传入享元对象的内部。一个外部状态与另一个外部状态之间是相互独立的。比如围棋的位置属性。

图 享元模式结构图

Flyweight: 抽象享元类，通常是一个接口或抽象类。声明的方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（状态）。

ConcreteFlyweight: 具体享元类，其实例称为享元对象。为内部状态提供了存储空间。通常可以结合单例模式来设计具体享元类。

UnsharedConcreteFlyweight: 非共享具体享元类。并不是所有抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类。当需要一个非共享具体享元对象时，可以直接通过实例化创建。

FlyweightFactory: 享元工厂类，用于创建并管理享元对象，针对抽象享元类编程，将各种类型的具体享元对象存储在一个享元池中。

public class Coordinate {private int x;private int y;public Coordinate(int x, int y) {this.x = x;this.y = y;}public int getX() {return x;}public void setX(int x) {this.x = x;}public int getY() {return y;}public void setY(int y) {this.y = y;}@Overridepublic String toString() {return "{" +"x=" + x +", y=" + y +'}';}
}
public abstract class AbstractChess {public abstract String getColor();public void display(Coordinate coordinate) {System.out.println(getColor() + "落在" + coordinate);}}public class BlackChess extends AbstractChess{@Overridepublic String getColor() {return "黑棋";}private BlackChess() {}private static class ClassHolder {private static final BlackChess instance = new BlackChess();}public static BlackChess getInstance() {return ClassHolder.instance;}}public class WhiteChess extends AbstractChess{@Overridepublic String getColor() {return "白棋";}private WhiteChess() {}private static class ClassHolder {private static final WhiteChess instance = new WhiteChess();}public static WhiteChess getInstance() {return ClassHolder.instance;}}public class Client {// 存储外部状态（棋子的位置）private static final List<Coordinate> whiteCoordinateList = new ArrayList<>();private static final List<Coordinate> blackCoordinateList = new ArrayList<>();static {whiteCoordinateList.add(new Coordinate(1,4));whiteCoordinateList.add(new Coordinate(2,3));whiteCoordinateList.add(new Coordinate(3,9));blackCoordinateList.add(new Coordinate(2,5));blackCoordinateList.add(new Coordinate(6,9));blackCoordinateList.add(new Coordinate(7,1));}public static void main(String[] args) {for (int i = 0; i < blackCoordinateList.size() && i < whiteCoordinateList.size(); i++) {// 无论下了多少步，黑白棋子都只各创建了一个实例WhiteChess.getInstance().display(whiteCoordinateList.get(i));BlackChess.getInstance().display(blackCoordinateList.get(i));}
//        运行结果：
//        白棋落在{x=1, y=4}
//        黑棋落在{x=2, y=5}
//        白棋落在{x=2, y=3}
//        黑棋落在{x=6, y=9}
//        白棋落在{x=3, y=9}
//        黑棋落在{x=7, y=1}}}

1.1 单纯享元模式

在单纯享元模式中，所有的具体享元类都是可以共享的，不存在非共享具体享元类。

​​​​​​​1.2 复合享元模式

将一些单纯享元对象使用组合模式加以组合，形成复合享元对象。这样的复合对象本身不能共享，但是它们包括的单纯享元对象可以被共享。

图 复合享元模式结构图

复合享元模式可以确保复合享元类CompositeConcreteFlyweight中所包含的每个单纯享元类都具有相同的外部状态，而这些单纯享元的内部状态往往可以不同。

现实中，当男女双方结婚组合成一个家庭后，虽然双方在有些观念上有分歧，但是夫妻双方二人都会一起为这个家付出的。

public abstract class AbstractRole {public abstract String getRole();void forHome(String things) {System.out.println(getRole() + ":" + things );}}public class HusbandRole extends AbstractRole{@Overridepublic String getRole() {return "丈夫";}private HusbandRole() {}public static class ClassHolder {private final static HusbandRole instance = new HusbandRole();}public static HusbandRole getInstance() {return ClassHolder.instance;}}public class WifeRole extends AbstractRole{@Overridepublic String getRole() {return "妻子";}private WifeRole() {}private static class ClassHolder {private final static WifeRole instance = new WifeRole();}public static WifeRole getInstance() {return ClassHolder.instance;}}public class CompositeManAndWife extends AbstractRole{private final WifeRole wifeRole = WifeRole.getInstance();private final HusbandRole husbandRole = HusbandRole.getInstance();@Overridepublic String getRole() {return wifeRole.getRole() + "和" + husbandRole.getRole();}private CompositeManAndWife() {}private static class ClassHolder {private final static CompositeManAndWife instance = new CompositeManAndWife();}public static CompositeManAndWife getInstance() {return ClassHolder.instance;}}public class Client {public static void main(String[] args) {CompositeManAndWife.getInstance().forHome("赚奶粉钱");CompositeManAndWife.getInstance().forHome("孝敬父母");CompositeManAndWife.getInstance().forHome("去旅行");
//        运行结果：
//        妻子和丈夫:赚奶粉钱
//        妻子和丈夫:孝敬父母
//        妻子和丈夫:去旅行}
}

2 Java的String

public class StringTest {public static void main(String[] args) {String str1 = "hello 享元模式";String str2 = "hello 享元模式";String str3 = new String("hello 享元模式");String str4 = "hello " + "享元模式";String str5 = "hello ";str5 += "享元模式";System.out.println(str1 == str2); //trueSystem.out.println(str1 == str3); //falseSystem.out.println(str1 == str4); //trueSystem.out.println(str1 == str5); //false}}

JVM 开辟了一块存储区专门存储字符串常量，叫作字符串常量池（享元池），而不同的字符串则为不同的享元实体。当给String变量赋值字符串常量时，会在字符串常量池中创建这个字符串享元实体（如果不存在的话）。

而通过new String(“”)的方式创建时则另开辟一个内存空间，而不会直接从字符串常量池中取。最后一个判断为false，是因为str5 的初始字符串和比较的字符串不一致，然后str5通过”+”号连接字符串时，会创建新的字符串变量。

3 享元模式优缺点

优点：

1. 客户极大减少内存中对象的数量，使得相同或相似对象在内存中只保存一份。
2. 享元模式的外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同环境中被共享。

缺点：

1. 需要分离出内部状态和外部状态，使系统变得复杂。
2. 为了使对象可以共享，将享元对象的部分状态外部化，而读取外部状态将使得运行时间变长。

4 适用场景

1. 系统中有大量相同或者相似的对象。
2. 对象中大部分状态都可以外部化。
3. 需要多次使用同一享元对象。