享元模式（Flyweight Pattern）

享元模式是一种结构型设计模式，用于减少对象的内存占用和提高性能。它通过共享相似对象的公共部分，来减少对象的重复创建，从而降低内存消耗。

结构

• 享元接口（Flyweight）： 定义了共享对象的接口，通常包括一些方法，用于获取和操作内部状态。

public interface Flyweight {
    void operation();
}

• 具体享元类（Concrete Flyweight）： 实现了享元接口，包含内部状态，并对其进行管理。

public class ConcreteFlyweight implements Flyweight {
    private String intrinsicState;

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

    public void operation() {
        System.out.println("Concrete Flyweight: " + intrinsicState);
    }
}

• 享元工厂（Flyweight Factory）： 管理享元对象的创建和共享，维护一个享元对象池，以确保对象的共享性。

public 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;
        }
    }
}

优点和缺点

优点：

1. 减少内存消耗： 享元模式通过共享相似对象的公共部分，减少了对象的内存占用，特别适用于大量相似对象的情况。
2. 提高性能： 由于减少了对象的创建和销毁，享元模式可以提高系统的性能。
3. 灵活性： 享元模式允许对象的内部状态和外部状态分离，使得对象更容易共享和复用。

缺点：

1. 增加复杂性： 引入享元模式可能增加系统的复杂性，需要维护享元工厂来管理共享对象。
2. 不适用于所有情况： 享元模式适用于有大量相似对象的情况，对于不共享内部状态的对象不适用。

示例

以下是一个享元模式的示例，表示不同颜色的方块共享相同的形状。在这个示例中，Shape 表示形状的接口，ConcreteShape 表示具体的形状，ShapeFactory 是享元工厂，负责管理共享的形状对象。

// 享元接口
public interface Shape {
    void draw(int x, int y);
}

// 具体享元类
public class ConcreteShape implements Shape {
    private String color;

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

    public void draw(int x, int y) {
        System.out.println("Draw a " + color + " square at (" + x + ", " + y + ")");
    }
}

// 享元工厂
import java.util.HashMap;
import java.util.Map;

public class ShapeFactory {
    private Map<String, Shape> shapes = new HashMap<>();

    public Shape getShape(String color) {
        if (shapes.containsKey(color)) {
            return shapes.get(color);
        } else {
            Shape shape = new ConcreteShape(color);
            shapes.put(color, shape);
            return shape;
        }
    }
}

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

        Shape redSquare = factory.getShape("red");
        redSquare.draw(10, 10);

        Shape blueSquare = factory.getShape("blue");
        blueSquare.draw(20, 20);

        Shape greenSquare = factory.getShape("green");
        greenSquare.draw(30, 30);
    }
}

在这个例子中，ShapeFactory 确保了相同颜色的方块共享相同的形状对象，从而减少了内存占用。客户端可以根据需要获取不同颜色的方块，并在不同位置绘制它们。享元模式有效减少了形状对象的创建。