设计模式-享元模式

享元模式（Flyweight Pattern）是一种结构型设计模式，它旨在通过共享对象来减少内存使用和提高性能。享元模式通过将对象的状态分为内部状态（Intrinsic State）和外部状态（Extrinsic State），共享相同的内部状态并存储在享元对象中，而将外部状态作为方法参数传递，以实现对象的共享。

 

以下是享元模式的关键要素：

1. Flyweight（享元）：定义享元对象的接口，包含设置外部状态的方法。
2. ConcreteFlyweight（具体享元）：实现享元接口，存储内部状态，并在需要时处理外部状态。
3. FlyweightFactory（享元工厂）：负责创建和管理享元对象，维护一个享元池用于存储共享对象。
4. Client（客户端）：使用享元模式的客户端，通过享元工厂获取共享对象，并传递外部状态。

 

享元模式的核心思想是共享对象，以减少对内存的占用。通过将对象的内部状态共享，可以在系统中复用对象，从而减少内存使用量。而外部状态作为方法参数传递，使得对象可以根据不同的外部状态进行不同的操作。由于内部状态是共享的，所以在不同的上下文中可以共享相同的对象。

 

享元模式的主要优点包括：

1. 减少内存消耗：通过共享享元对象的内部状态，可以减少系统中对象的数量，从而减少内存消耗。这对于大规模使用相似对象的系统来说特别有用。
2. 提高性能：减少了对象的数量和内存消耗，可以提高系统的性能。共享对象的访问速度通常比创建新对象的速度更快。
3. 简化对象结构：享元模式将对象的内部状态与外部状态进行分离，使得对象结构变得更加简单。对象的外部状态可以通过参数传递，而不需要在对象内部进行维护。
4. 增加可扩展性：当需要引入新的对象时，可以通过在工厂中创建和共享现有对象来实现，而不需要创建新的对象。这样可以减少代码的修改量，并增加系统的可扩展性。

 

然而，享元模式也存在一些缺点：

1. 共享状态的限制：由于多个对象共享内部状态，改变一个对象的状态可能会影响其他对象的行为。因此，享元对象的内部状态必须是不可变的。
2. 对象共享的复杂性：通过共享对象来减少内存消耗可能会增加系统的复杂性。需要维护共享对象的池以及对象的内部状态和外部状态之间的关系。
3. 空间换时间：享元模式通过共享对象来减少内存消耗，但在某些情况下，这可能会增加系统的时间复杂度。例如，在多线程环境下，需要对共享对象进行同步处理，这可能会导致性能下降。

 

相比于每个对象都存储全部状态的做法，享元模式可以大大减少系统的内存占用，提高系统的性能和效率。然而，享元模式也存在一些缺点，例如增加了系统的复杂性，需要维护共享对象池。此外，共享对象的状态是共享的，所以要注意外部状态对共享对象的影响，需要保证外部状态的一致性。

 

下面是一个使用享元模式的简单示例，展示了如何共享相似的对象以减少内存消耗：

// 享元工厂类
class ShapeFactory {
    private static final Map<String, Shape> shapes = new HashMap<>();

    // 获取共享对象
    public static Shape getShape(String color) {
        Shape shape = shapes.get(color);

        // 如果共享对象不存在，则创建新对象并加入共享池中
        if (shape == null) {
            shape = new Circle(color);
            shapes.put(color, shape);
        }

        return shape;
    }
}

// 抽象享元类
interface Shape {
    void draw();
}

// 具体享元类
class Circle implements Shape {
    private final String color;

    public Circle(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a circle with color: " + color);
    }
}

// 客户端代码
public class FlyweightDemo {
    public static void main(String[] args) {
        // 创建3个红色圆形对象，但实际只有一个Circle对象被创建
        Shape redCircle = ShapeFactory.getShape("red");
        redCircle.draw();

        Shape anotherRedCircle = ShapeFactory.getShape("red");
        anotherRedCircle.draw();

        Shape yetAnotherRedCircle = ShapeFactory.getShape("red");
        yetAnotherRedCircle.draw();

        // 创建2个蓝色圆形对象，但实际只有一个Circle对象被创建
        Shape blueCircle = ShapeFactory.getShape("blue");
        blueCircle.draw();

        Shape anotherBlueCircle = ShapeFactory.getShape("blue");
        anotherBlueCircle.draw();
    }
}

在上面的示例中，ShapeFactory充当享元工厂，通过维护一个享元对象的池来实现对象的共享。Circle类是具体的享元类，表示圆形对象。客户端通过ShapeFactory获取共享对象，并调用draw方法进行绘画。由于红色和蓝色圆形对象是相似的，并且共享相同的内部状态，所以只创建了一个Circle对象来共享使用。

输出结果为：

Drawing a circle with color: red
Drawing a circle with color: red
Drawing a circle with color: red
Drawing a circle with color: blue
Drawing a circle with color: blue

可以看到，虽然创建了多个相似的圆形对象，但实际只有一个Circle对象被创建和共享使用，从而减少了内存消耗。

总而言之，享元模式通过共享相同的内部状态来减少内存使用和提高性能。它在需要创建大量相似对象的场景下具有很好的应用价值，可以显著减少系统的内存占用，提高系统的性能和效率。