结构模式之一旨在通过与相似对象共享尽可能多的数据来减少内存使用。
在处理大量相似对象时特别有用，为每个对象创建一个新实例在内存消耗方面会非常昂贵。
关键概念：
内在状态：多个对象之间共享的状态独立于上下文，并且在不同对象之间保持相同。
外部状态：每个对象唯一的、从客户端传递的状态。此状态可能会有所不同，并且不会存储在 Flyweight 对象中

主要参与者：

Flyweight：Flyweight对象接收外部状态并使用它的接口。
ConcreteFlyweight：实现 Flyweight 并存储内在状态。
FlyweightFactory：管理Flyweight对象并确保接口共享，如果存在则返回一个现有的Flyweight。

Client（如 Main 类）：维护对 Flyweight 的引用，并在需要与 Flyweight 对象交互时提供外部状态。

我们以角色的 Flyweight 对象为例
假设我们有一个文本编辑器需要渲染大量文本。每个字符都可以表示为一个对象，但是为每个字符都有一个单独的对象会浪费大量内存。相反，我们可以使用 Flyweights 来共享代表每个字母的字符对象，并存储外部状态，例如外部的位置或格式

蝇量级

public interface Flyweight {
    public void display(int x, int y);//x, y are the extrinsic state of the Flyweight object
}

混凝土享元

public class CharacterFlyweight implements Flyweight {
    private char ch;
    public CharacterFlyweight(char c){
        this.ch  = c;
    }
    @Override
    public void display(int x ,int y){
        System.out.println("[drawing character: " this.ch " at co-ordinates:(" x "," y ")]");
    }

}

FlyweightFactory

public class FlyweightFactory {
    private static HashMap flyweights = new HashMap();
    public static Flyweight getFlyweight(char c){
        Flyweight flyweight = flyweights.getOrDefault(c,null);
        if(null==flyweight){
            flyweight = new CharacterFlyweight(c);
            flyweights.put(c,flyweight);
        }
        return flyweight;
    }
}

主要的

public class Main {
    public static void main(String args[]){
        Flyweight flyweight1 = FlyweightFactory.getFlyweight('a');
        Flyweight flyweight2 = FlyweightFactory.getFlyweight('b');
        Flyweight flyweight3 = FlyweightFactory.getFlyweight('a');// will use the same object that is referenced by flyweight1

        flyweight1.display(1, 2);//'a' displayed at 1,2
        flyweight2.display(3, 4);//'b' displayed at 3,4
        flyweight3.display(5, 7); // 'a'(shared) displayed at 5,7
    }
}

输出：

[drawing character: a at co-ordinates:(1,2)]
[drawing character: b at co-ordinates:(3,4)]
[drawing character: a at co-ordinates:(5,7)]

要点

• 内存效率：通过共享对象减少内存使用，特别是当内在状态很大或对象很多时。
• 性能改进：减少创建的对象数量，可以提高应用程序在管理大量对象时的性能。

缺点
复杂性：该模式会增加代码的复杂性，特别是在分别管理外部和内部状态时。
开销：如果要共享的对象很少，享元模式可能会引入不必要的复杂性，而不会显着节省内存。