7种结构型模式之享元模式（六）

最新推荐文章于 2021-09-08 17:57:23 发布

weixin_43828846

最新推荐文章于 2021-09-08 17:57:23 发布

阅读量76

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.youkuaiyun.com/weixin_43828846/article/details/112848201

版权

设计模式专栏收录该内容

19 篇文章

订阅专栏

本文介绍了享元模式的概念、特点及应用场景，通过实例演示了如何利用享元模式减少系统中对象的数量，进而降低内存消耗。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

博客参考自：享元模式

在面向对象程序设计过程中，有时会面临要创建大量相同或相似对象实例的问题。创建那么多的对象将会耗费很多的系统资源，它是系统性能提高的一个瓶颈。

例如，围棋和五子棋中的黑白棋子，如果能把它们相同的部分提取出来共享，则能节省大量的系统资源，这就是享元模式的产生背景。

定义与特点

享元（Flyweight）模式的定义：运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。

优点

相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。

缺点

为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。
读取享元模式的外部状态会使得运行时间稍微变长。

结构与实现

享元模式的定义提出了两个要求，细粒度和共享对象。因为要求细粒度，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。

内部状态：指对象共享出来的信息，存储在享元信息内部，并且不回随环境的改变而改变；
外部状态：指对象得以依赖的一个标记，随环境的改变而改变，不可共享。

比如，围棋的棋子，每一颗棋子都是一个对象，都要如下属性：颜色、形状、大小，这些都是可以共享的，被称为内部状态。而每颗棋子的落子位置，是不能共享的，被称为外部状态。

享元模式的本质是缓存共享对象，降低内存消耗。

模式的结构

享元模式的主要角色有如下。

抽象享元（Flyweight） 角色：是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
具体享元（Concrete Flyweight） 角色：实现抽象享元角色中所规定的接口。
非享元（Unsharable Flyweight) 角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
享元工厂（Flyweight Factory） 角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

其结构图如下，其中：

UnsharedConcreteFlyweight 是非享元角色，里面包含了非共享的外部状态信息 info；
Flyweight 是抽象享元角色，里面包含了享元方法 operation(UnsharedConcreteFlyweight state)，非享元的外部状态以参数的形式通过该方法传入；
ConcreteFlyweight 是具体享元角色，包含了关键字 key，它实现了抽象享元接口；
FlyweightFactory 是享元工厂角色，它是关键字 key 来管理具体享元；
客户角色通过享元工厂获取具体享元，并访问具体享元的相关方法。

模式的实现

非享元角色

class UnsharedConcreteFlyweight {
    private String info;
    UnsharedConcreteFlyweight(String info) {
        this.info = info;
    }
    public String getInfo() {
        return info;
    }
    public void setInfo(String info) {
        this.info = info;
    }
}

抽象享元角色

interface Flyweight {
    public void operation(UnsharedConcreteFlyweight state);
}

具体享元角色

class ConcreteFlyweight implements Flyweight {
    private String key;
    ConcreteFlyweight(String key) {
        this.key = key;
        System.out.println("具体享元" + key + "被创建！");
    }
    @Override
    public void operation(UnsharedConcreteFlyweight outState) {
        System.out.print("具体享元" + key + "被调用，");
        System.out.println("非享元信息是:" + outState.getInfo());
    }
}

享元工厂角色

class FlyweightFactory {

    private static HashMap<String, Flyweight> flyweights = new HashMap<>();

    public static Flyweight getFlyweight(String key) {

        Flyweight flyweight =  flyweights.get(key);
        if (flyweight != null) {
            System.out.println("具体享元" + key + "已经存在，被成功获取！");
        } else {
            flyweight = new ConcreteFlyweight(key);
            flyweights.put(key, flyweight);
        }
        return flyweight;
    }
}

客户端调用

public class FlyweightTest {

    public static void main(String[] args) {
        Flyweight f01 = FlyweightFactory.getFlyweight("a");
        System.out.println(f01);
        Flyweight f02 = FlyweightFactory.getFlyweight("a");
        System.out.println(f02);
        Flyweight f11 = FlyweightFactory.getFlyweight("b");
        System.out.println(f11);
        f01.operation(new UnsharedConcreteFlyweight("第1次调用a。"));
    }

}

程序运行结果如下：

具体享元a被创建！
shijims.structure.e_flyweight.ConcreteFlyweight@6d6f6e28
具体享元a已经存在，被成功获取！
shijims.structure.e_flyweight.ConcreteFlyweight@6d6f6e28
具体享元b被创建！
shijims.structure.e_flyweight.ConcreteFlyweight@135fbaa4
具体享元a被调用，非享元信息是:第1次调用a。

应用实例

【例1】享元模式在五子棋游戏中的应用.

外部状态：棋子坐标位置

class Coordinate {
    private int x, y;

    public Coordinate(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

抽象享元：棋子

interface ChessPieces {
    void display(Coordinate c);//展示位置，外部状态
}

具体享元

class ConcreteChess implements ChessPieces {
    private String color;

    public ConcreteChess(String color) {
        super();
        this.color = color;
    }

    @Override
    public void display(Coordinate c) {
        System.out.println("棋子颜色：" + color);
        System.out.println("棋子位置" + c.getX() + "-----" + c.getY());
    }

}

享元工厂

class ChessPiecesFactory {
   //享元池
    private static Map<String, ChessPieces> map = new HashMap<>();

    public static ChessPieces getChess(String color) {
        if (map.get(color) != null) {
            return map.get(color);
        } else {
            ChessPieces chessPieces = new ConcreteChess(color);
            map.put(color, chessPieces);
            return chessPieces;
        }
    }
}

客户端调用

public class Client {

    public static void main(String[] args) {
        ChessPieces chess1 = ChessPiecesFactory.getChess("黑色");
        ChessPieces chess2 = ChessPiecesFactory.getChess("黑色");
        System.out.println(chess1);
        System.out.println(chess2);

        System.out.println("-----增加外部状态的处理----");
        chess1.display(new Coordinate(10, 10));
        chess2.display(new Coordinate(20, 20));

    }

}

程序运行结果如下：

shijims.structure.f_flyweight.ConcreteChess@6d6f6e28
shijims.structure.f_flyweight.ConcreteChess@6d6f6e28
-----增加外部状态的处理----
棋子颜色：黑色
棋子位置10-----10
棋子颜色：黑色
棋子位置20-----20