设计模式-FlyWeight模式（享元模式）

什么是享元模式

将那些内部状态可以共享的对象只保留一份，管理起来，每次使用时都用同一份内部状态相同的对象。
感觉和单例模式有点相似，但是享元模式只是将那些内部状态相同的对象保留起来，单例模式则是指定任意一个类在系统中只生成一个对象。

示例程序

示例程序是将输入的字符串中的每一个字符都按一定格式输出。
这个格式就是类BigChar，它会将输入的char，以“图片”的形式展示。

具体享元：BigChar享元角色，相同内部状态的对象只保留一份，这里的状态指的就是具体哪个字符，它可以被享元工厂管理起来。

public class BigChar {
    private char charname;
    private String fontdata;

    public BigChar(char charname) {
        this.charname = charname;

        try {
            BufferedReader reader = new BufferedReader(new FileReader("big" + charname + ".txt"));
            String line;
            StringBuffer buf = new StringBuffer();
            while ( (line = reader.readLine()) != null) {
                buf.append(line);
                buf.append("\n");
            }
            reader.close();
            this.fontdata = buf.toString();
        } catch (IOException e) {
            this.fontdata = charname + "?";
        }
    }

    public void print() {
        System.out.print(fontdata);
    }
}

享元工厂：BigCharFactory管理者角色，用来管理现有的享元对象，并对外提供状态相同的享元对象。作为单例使用

public class BigCharFactory {
    public static BigCharFactory singleton = new BigCharFactory();

    private HashMap pool = new HashMap();

    private BigCharFactory() {
    }

    public static BigCharFactory getInstance() {
        return singleton;
    }

    // 生成（共享）BigChar类的实例
    public synchronized BigChar getBigChar(char charname) {
        BigChar bc = (BigChar) pool.get(charname);
        if (Objects.isNull(bc)) {
            bc = new BigChar(charname);
            pool.put(charname, bc);
        }
        return bc;
    }

}

BigString类：Client客户端角色，用来请求获得享元对象，它有享元工厂对象，根据输入的String，按字符依次从享元工厂获得享元对象，并放在一个数组中。

public class BigString {

    private BigChar[] bigchars;

    public BigString(String string) {
        bigchars = new BigChar[string.length()];
        BigCharFactory factory = BigCharFactory.getInstance();

        for (int i = 0; i < string.length(); i++) {
            bigchars[i] = factory.getBigChar(string.charAt(i));
        }
    }

    public void print() {
        for (int i = 0; i < bigchars.length; i++) {
            bigchars[i].print();
        }
    }
}

测试类

public class Main {
    public static void main(String[] args) {
        BigString bs = new BigString("13212");
        bs.print();
    }
}

为什么要用享元模式

1. 便于维护共享的对象，避免重复生成浪费内存

享元模式在java中的使用场景

典型的就是String类的维护，对象一旦创建就不可改变，同时JAVA会确保一个字符串常量（例如：“Flyweight”）在常量池中只能存在一份拷贝。
常量池就有点类似于享元工厂的角色，用来管理字符串（享元对象）。