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

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

 图 围棋

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;
    }

    @Override
    public 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{
    @Override
    public 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{

    @Override
    public 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{
    @Override
    public 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{
    @Override
    public 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();

    @Override
    public 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); //true
        System.out.println(str1 == str3); //false
        System.out.println(str1 == str4); //true
        System.out.println(str1 == str5); //false
    }

}

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

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

3 享元模式优缺点

优点：

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

缺点：

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

4 适用场景

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