编辑“︁Java享元模式”︁

{{DISPLAYTITLE:Java享元模式}}

'''享元模式'''（Flyweight Pattern）是一种结构型设计模式，旨在通过共享尽可能多的相似对象来减少内存使用或计算开销。该模式特别适用于需要创建大量相似对象的场景，通过共享这些对象的公共部分来优化性能。

== 概述 ==
享元模式的核心思想是将对象的'''内在状态'''（Intrinsic State）和'''外在状态'''（Extrinsic State）分离：
* '''内在状态'''：存储在享元对象内部且可以共享的部分，通常不随环境变化。
* '''外在状态'''：依赖于上下文且不可共享的部分，通常由客户端代码维护。

通过共享内在状态，享元模式显著减少了系统中对象的数量，从而降低了内存占用。

=== 适用场景 ===
* 程序中需要创建大量相似对象。
* 对象的大部分状态可以外部化。
* 由于使用大量对象导致内存开销过高。

== 结构 ==
享元模式的主要参与者包括：
* '''Flyweight'''：定义享元对象的接口。
* '''ConcreteFlyweight'''：实现Flyweight接口，并为内部状态增加存储。
* '''FlyweightFactory'''：创建并管理享元对象，确保合理共享。
* '''Client'''：维护外部状态，并在需要时调用享元对象。

<mermaid>
classDiagram
    class Flyweight {
        +operation(extrinsicState)
    }
    class ConcreteFlyweight {
        -intrinsicState
        +operation(extrinsicState)
    }
    class FlyweightFactory {
        -flyweights: Map
        +getFlyweight(key)
    }
    class Client {
        -extrinsicState
    }
    Flyweight <|-- ConcreteFlyweight
    FlyweightFactory o-- Flyweight
    Client --> Flyweight
    Client --> FlyweightFactory
</mermaid>

== 代码示例 ==
以下是一个简单的享元模式实现，模拟文本编辑器中的字符渲染：

<syntaxhighlight lang="java">
import java.util.HashMap;
import java.util.Map;

// Flyweight接口
interface Character {
    void display(String font);
}

// ConcreteFlyweight
class ConcreteCharacter implements Character {
    private final char symbol;

    public ConcreteCharacter(char symbol) {
        this.symbol = symbol;
    }

    @Override
    public void display(String font) {
        System.out.printf("Character: %s, Font: %s%n", symbol, font);
    }
}

// FlyweightFactory
class CharacterFactory {
    private static final Map<Character, ConcreteCharacter> characters = new HashMap<>();

    public static Character getCharacter(char symbol) {
        return characters.computeIfAbsent(symbol, ConcreteCharacter::new);
    }
}

// Client
public class TextEditor {
    public static void main(String[] args) {
        String text = "Hello, Flyweight!";
        String font = "Arial";

        for (char c : text.toCharArray()) {
            Character character = CharacterFactory.getCharacter(c);
            character.display(font);
        }
    }
}
</syntaxhighlight>

'''输出示例'''：
 Character: H, Font: Arial
 Character: e, Font: Arial
 Character: l, Font: Arial
 ...
（重复的字符如'l'会共享同一个ConcreteCharacter实例）

== 实际应用案例 ==
享元模式在以下场景中广泛应用：
1. '''游戏开发'''：渲染大量相似游戏对象（如树木、子弹）时共享纹理和模型。
2. '''文本处理'''：文档编辑器中对相同字符的字形共享。
3. '''数据库连接池'''：复用已建立的连接对象。

=== 游戏场景示例 ===
在RPG游戏中，同一类型的怪物可能有数千个实例，但它们的纹理、模型和动画可以共享：

<syntaxhighlight lang="java">
// 内在状态：怪物类型属性
class MonsterType {
    private final String name;
    private final String texture;
    private final String model;

    public MonsterType(String name, String texture, String model) { /*...*/ }
    // getters...
}

// 外在状态：怪物位置和血量
class Monster {
    private final MonsterType type;
    private int x, y;
    private int health;

    public Monster(MonsterType type, int x, int y) { /*...*/ }
    public void render() {
        System.out.printf("Rendering %s at (%d,%d)%n", 
            type.getName(), x, y);
    }
}
</syntaxhighlight>

== 数学原理 ==
享元模式的内存节省可以通过以下公式量化：
<math>
\Delta M = (n - k) \times s_i
</math>
其中：
* <math>n</math>：原始对象数量
* <math>k</math>：共享后的唯一享元数量
* <math>s_i</math>：每个对象的内在状态大小

== 优缺点 ==
{| class="wikitable"
|-
! 优点 !! 缺点
|-
| 减少内存使用 || 增加代码复杂度
|-
| 提高性能（减少对象创建） || 需要仔细设计状态分离
|-
| 适用于大量细粒度对象 || 可能引入线程安全问题
|}

== 扩展阅读 ==
* 与[[单例模式]]的区别：享元模式允许存在多个不同状态的实例，而单例严格限制为一个实例。
* 与[[对象池]]的区别：对象池管理生命周期可变的实例，享元对象通常是不可变的。

== 总结 ==
享元模式通过共享对象的内在状态，有效解决了大量相似对象导致的内存消耗问题。正确应用该模式需要：
# 明确区分内在/外在状态
# 设计合适的享元工厂
# 确保享元对象的线程安全性

在Java标准库中，<code>java.lang.String</code>的常量池和<code>java.lang.Integer#valueOf()</code>的缓存机制都是享元模式的典型实现。

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java设计模式]]