设计模式之享元模式

        享元模式是一种结构型设计模式，它通过共享对象来有效地支持大量细粒度的对象共享，以减少内存占用和提高性能。

        享元模式的核心思想是将对象分为内部状态（Intrinsic State）和外部状态（Extrinsic State）。内部状态是可以被多个对象共享的，而外部状态是每个对象独立拥有的。通过共享内部状态，可以减少对象的创建和存储开销。

享元模式的关键要素包括：

• 享元接口：定义了共享对象的接口，包含对内部状态和外部状态的操作方法。
• 具体享元类：实现了享元接口，包含了内部状态，并为内部状态提供了共享。
• 享元工厂类：负责创建和管理享元对象，可以通过工厂方法获取享元对象。
• 客户端：使用享元对象的客户端代码，通过享元工厂获取享元对象，并设置外部状态。

享元模式的优点包括：

• 减少内存占用和对象创建的开销，提高了系统性能。
• 提供了对象的复用，可以共享对象，减少了对象的数量。
• 分离了内部状态和外部状态，使得系统更易于扩展和维护。

下面是一个简单的享元模式示例：

// 享元接口
interface Flyweight {
    void operation(String extrinsicState);
}

// 具体享元类
class ConcreteFlyweight implements Flyweight {
    private String intrinsicState;

    public ConcreteFlyweight(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }

    public void operation(String extrinsicState) {
        System.out.println("Intrinsic state: " + intrinsicState);
        System.out.println("Extrinsic state: " + extrinsicState);
    }
}

// 享元工厂类
class FlyweightFactory {
    private Map<String, Flyweight> flyweights = new HashMap<>();

    public Flyweight getFlyweight(String key) {
        if (flyweights.containsKey(key)) {
            return flyweights.get(key);
        } else {
            Flyweight flyweight = new ConcreteFlyweight(key);
            flyweights.put(key, flyweight);
            return flyweight;
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();

        Flyweight flyweight1 = factory.getFlyweight("key1");
        flyweight1.operation("state1");

        Flyweight flyweight2 = factory.getFlyweight("key2");
        flyweight2.operation("state2");

        Flyweight flyweight3 = factory.getFlyweight("key1");
        flyweight3.operation("state3");
    }
}

输出结果：

         在上述示例中，我们定义了享元接口Flyweight，并实现了具体享元类ConcreteFlyweight。享元工厂类FlyweightFactory负责创建和管理享元对象。

        在客户端代码中，我们通过享元工厂获取享元对象，并设置外部状态。在第一次获取享元对象时，工厂会创建新的享元对象并将其缓存起来。在后续获取同样外部状态的享元对象时，工厂直接返回缓存中的对象。

                通过享元模式，我们可以有效地共享对象，减少内存占用和对象创建的开销。这种方式适用于需要大量细粒度对象的场景，并且可以提高系统性能和资源利用率。