当前位置：首页 > article >正文

设计模式教程：享元模式（Flyweight Pattern）

article 2025/2/21 10:09:02

享元模式（Flyweight Pattern）是一种结构型设计模式，用于减少对象的创建数量，避免大量相似对象的内存占用。它通过共享对象来有效支持大量的细粒度对象，尤其是在需要大量类似对象的情况下，享元模式可以显著节省内存。

1. 享元模式的定义

享元模式通过将相同或相似的对象共享来节省内存，尤其适用于那种大量相似对象的场景。例如，在绘图软件中，每个图形（如圆形、方形等）都可能有颜色、大小等不同的属性。享元模式可以将共享的部分提取出来，将不变的部分共享，而将变化的部分放入外部的状态中。

2. 享元模式的角色

Flyweight（享元角色）：定义共享对象的接口，并提供存储共享状态的方法。
ConcreteFlyweight（具体享元角色）：实现享元角色接口，负责存储并管理共享的状态。
UnsharedConcreteFlyweight（非共享享元角色）：某些状态无法共享时，会有一些非共享享元类用于存储非共享的状态。
FlyweightFactory（享元工厂角色）：负责管理享元对象的创建和共享。确保享元对象的复用，并在需要时返回相同的享元实例。

3. 享元模式的核心思想

共享：将多个对象中共享的部分提取出来，放到一个共享池中，供多个对象复用。
外部状态：将不变的部分共享给所有对象，而可变的部分则交给外部来管理。

4. 享元模式的应用场景

当系统有大量相似对象需要存储时，特别是当这些对象的状态占用大量内存时。
对象的状态可以分为共享的部分和不共享的部分，不共享部分可以通过外部传入。
对象状态的共享可以显著节省内存。

5. 享元模式的结构图

 +-------------------+
 |    Flyweight      |<-----------------------+
 +-------------------+                        |
 | - sharedState     |                        |
 | + operation()     |                        |
 +-------------------+                        |
         ^                                     |
         |                                     |
 +------------------------+                   |
 | ConcreteFlyweight      |                   |
 +------------------------+                   |
 | - sharedState          |                   |
 | + operation()          |                   |
 +------------------------+                   |
         ^                                     |
         |                                     |
 +--------------------------+                 |
 | UnsharedConcreteFlyweight|-----------------+
 +--------------------------+
 | - uniqueState            |
 | + operation()            |
 +--------------------------+

6. 享元模式的代码示例

以 棋盘游戏 为例，假设我们有大量的棋子，每个棋子都需要设置颜色和类型。享元模式可以减少内存使用，避免重复创建相同类型和颜色的棋子对象。

享元模式实现：

// 享元角色：Flyweight（享元类）
interface ChessPiece {
    void display(String position);
}

// 具体享元角色：ConcreteFlyweight（具体享元类）
class ConcreteChessPiece implements ChessPiece {
    private String type; // 棋子的类型

    public ConcreteChessPiece(String type) {
        this.type = type;
    }

    @Override
    public void display(String position) {
        System.out.println("棋子类型：" + type + ", 位置：" + position);
    }
}

// 非共享享元角色：UnsharedConcreteFlyweight（非共享享元类）
class UnsharedConcreteChessPiece implements ChessPiece {
    private String type;
    private String color; // 棋子的颜色（非共享部分）

    public UnsharedConcreteChessPiece(String type, String color) {
        this.type = type;
        this.color = color;
    }

    @Override
    public void display(String position) {
        System.out.println("棋子类型：" + type + ", 颜色：" + color + ", 位置：" + position);
    }
}

// 享元工厂：FlyweightFactory（享元工厂）
class ChessPieceFactory {
    private Map<String, ChessPiece> chessPieceMap = new HashMap<>();

    public ChessPiece getChessPiece(String type) {
        ChessPiece piece = chessPieceMap.get(type);

        if (piece == null) {
            piece = new ConcreteChessPiece(type); // 如果工厂中没有该类型的棋子，就创建一个新的
            chessPieceMap.put(type, piece);
            System.out.println("创建新棋子：类型 " + type);
        }

        return piece;
    }
}

public class FlyweightPatternExample {
    public static void main(String[] args) {
        // 享元工厂
        ChessPieceFactory chessPieceFactory = new ChessPieceFactory();

        // 棋盘上的棋子
        ChessPiece whitePawn = chessPieceFactory.getChessPiece("兵");
        whitePawn.display("A1");

        ChessPiece blackKnight = chessPieceFactory.getChessPiece("马");
        blackKnight.display("B2");

        ChessPiece whitePawn2 = chessPieceFactory.getChessPiece("兵");
        whitePawn2.display("A2");

        // 非共享棋子
        ChessPiece blackQueen = new UnsharedConcreteChessPiece("皇后", "黑色");
        blackQueen.display("D1");
    }
}