设计模式之享元模式

最新推荐文章于 2024-11-15 18:26:06 发布
最新推荐文章于 2024-11-15 18:26:06 发布
阅读量263 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 享元模式 组合模式
JWei_7
本文链接：https://blog.csdn.net/qq_54729417/article/details/120299508
版权

设计模式之享元模式

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

例如，围棋和五子棋中的黑白棋子，图像中的坐标点或颜色，局域网中的路由器、交换机和集线器，教室里的桌子和凳子等。这些对象有很多相似的地方，如果能把它们相同的部分提取出来共享，则能节省大量的系统资源，这就是享元模式的产生背景。

享元模式的定义与特点

说白了 就是共享

定义

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

优缺点

享元模式的主要优点是：

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

其主要缺点是：

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

享元模式的结构与实现

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

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

比如，连接池中的连接对象，保存在连接对象中的用户名、密码、连接URL等信息，在创建对象的时候就设置好了，不会随环境的改变而改变，这些为内部状态。而当每个连接要被回收利用时，我们需要将它标记为可用状态，这些为外部状态。

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

1. 模式的结构

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

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

图 1 是享元模式的结构图，其中：

  1. UnsharedConcreteFlyweight 是非享元角色，里面包含了非共享的外部状态信息 info；

  2. Flyweight 是抽象享元角色，里面包含了享元方法 operation(UnsharedConcreteFlyweight
    state)，非享元的外部状态以参数的形式通过该方法传入；

  3. ConcreteFlyweight 是具体享元角色，包含了关键字 key，它实现了抽象享元接口；

  4. FlyweightFactory 是享元工厂角色，它是关键字 key 来管理具体享元；

  5. 客户角色通过享元工厂获取具体享元，并访问具体享元的相关方法。

在这里插入图片描述

2. 模式的实现

享元模式的实现代码如下：

public class FlyweightPattern {
    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();
        Flyweight f01 = factory.getFlyweight("a");
        Flyweight f02 = factory.getFlyweight("a");
        Flyweight f03 = factory.getFlyweight("a");
        Flyweight f11 = factory.getFlyweight("b");
        Flyweight f12 = factory.getFlyweight("b");
        f01.operation(new UnsharedConcreteFlyweight("第1次调用a。"));
        f02.operation(new UnsharedConcreteFlyweight("第2次调用a。"));
        f03.operation(new UnsharedConcreteFlyweight("第3次调用a。"));
        f11.operation(new UnsharedConcreteFlyweight("第1次调用b。"));
        f12.operation(new UnsharedConcreteFlyweight("第2次调用b。"));
    }
}
//非享元角色
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 + "被创建！");
    }
    public void operation(UnsharedConcreteFlyweight outState) {
        System.out.print("具体享元" + key + "被调用，");
        System.out.println("非享元信息是:" + outState.getInfo());
    }
}
//享元工厂角色
class FlyweightFactory {
    private HashMap<String, Flyweight> flyweights = new HashMap<String, Flyweight>();
    public Flyweight getFlyweight(String key) {
        Flyweight flyweight = (Flyweight) flyweights.get(key);
        if (flyweight != null) {
            System.out.println("具体享元" + key + "已经存在，被成功获取！");
        } else {
            flyweight = new ConcreteFlyweight(key);
            flyweights.put(key, flyweight);
        }
        return flyweight;
    }
}

程序运行结果如下：

具体享元a被创建！
具体享元a已经存在，被成功获取！
具体享元a已经存在，被成功获取！
具体享元b被创建！
具体享元b已经存在，被成功获取！
具体享元a被调用，非享元信息是:第1次调用a。
具体享元a被调用，非享元信息是:第2次调用a。
具体享元a被调用，非享元信息是:第3次调用a。
具体享元b被调用，非享元信息是:第1次调用b。
具体享元b被调用，非享元信息是:第2次调用b。

享元模式的应用实例

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

分析：五子棋同围棋一样，包含多个“黑”或“白”颜色的棋子，所以用享元模式比较好。

本实例中:

  • 棋子（ChessPieces）类是抽象享元角色，它包含了一个落子的 DownPieces(Graphics g,Point pt) 方法；
  • 白子（WhitePieces）和黑子（BlackPieces）类是具体享元角色，它实现了落子方法； Point 是非享元角色，它指定了落子的位置；
  • WeiqiFactory 是享元工厂角色，它通过 ArrayList 来管理棋子，并且提供了获取白子或者黑子的getChessPieces(String type) 方法；
  • 客户类（Chessboard）利用 Graphics 组件在框架窗体中绘制一个棋盘，并实现 mouseClicked(MouseEvente) 事件处理方法，该方法根据用户的选择从享元工厂中获取白子或者黑子并落在棋盘上。

图 2 所示是其结构图。
在这里插入图片描述
程序代码如下：

import javax.swing.*;
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
public class WzqGame {
    public static void main(String[] args) {
        new Chessboard();
    }
}
//棋盘
class Chessboard extends MouseAdapter {
    WeiqiFactory wf;
    JFrame f;
    Graphics g;
    JRadioButton wz;
    JRadioButton bz;
    private final int x = 50;
    private final int y = 50;
    private final int w = 40;    //小方格宽度和高度
    private final int rw = 400;    //棋盘宽度和高度
    Chessboard() {
        wf = new WeiqiFactory();
        f = new JFrame("享元模式在五子棋游戏中的应用");
        f.setBounds(100, 100, 500, 550);
        f.setVisible(true);
        f.setResizable(false);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JPanel SouthJP = new JPanel();
        f.add("South", SouthJP);
        wz = new JRadioButton("白子");
        bz = new JRadioButton("黑子", true);
        ButtonGroup group = new ButtonGroup();
        group.add(wz);
        group.add(bz);
        SouthJP.add(wz);
        SouthJP.add(bz);
        JPanel CenterJP = new JPanel();
        CenterJP.setLayout(null);
        CenterJP.setSize(500, 500);
        CenterJP.addMouseListener(this);
        f.add("Center", CenterJP);
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        g = CenterJP.getGraphics();
        g.setColor(Color.BLUE);
        g.drawRect(x, y, rw, rw);
        for (int i = 1; i < 10; i++) {
            //绘制第i条竖直线
            g.drawLine(x + (i * w), y, x + (i * w), y + rw);
            //绘制第i条水平线
            g.drawLine(x, y + (i * w), x + rw, y + (i * w));
        }
    }
    public void mouseClicked(MouseEvent e) {
        Point pt = new Point(e.getX() - 15, e.getY() - 15);
        if (wz.isSelected()) {
            ChessPieces c1 = wf.getChessPieces("w");
            c1.DownPieces(g, pt);
        } else if (bz.isSelected()) {
            ChessPieces c2 = wf.getChessPieces("b");
            c2.DownPieces(g, pt);
        }
    }
}
//抽象享元角色：棋子
interface ChessPieces {
    public void DownPieces(Graphics g, Point pt);    //下子
}
//具体享元角色：白子
class WhitePieces implements ChessPieces {
    public void DownPieces(Graphics g, Point pt) {
        g.setColor(Color.WHITE);
        g.fillOval(pt.x, pt.y, 30, 30);
    }
}
//具体享元角色：黑子
class BlackPieces implements ChessPieces {
    public void DownPieces(Graphics g, Point pt) {
        g.setColor(Color.BLACK);
        g.fillOval(pt.x, pt.y, 30, 30);
    }
}
//享元工厂角色
class WeiqiFactory {
    private ArrayList<ChessPieces> qz;
    public WeiqiFactory() {
        qz = new ArrayList<ChessPieces>();
        ChessPieces w = new WhitePieces();
        qz.add(w);
        ChessPieces b = new BlackPieces();
        qz.add(b);
    }
    public ChessPieces getChessPieces(String type) {
        if (type.equalsIgnoreCase("w")) {
            return (ChessPieces) qz.get(0);
        } else if (type.equalsIgnoreCase("b")) {
            return (ChessPieces) qz.get(1);
        } else {
            return null;
        }
    }
}

程序运行结果如图 3 所示。
在这里插入图片描述

享元模式的应用场景

当系统中多处需要同一组信息时，可以把这些信息封装到一个对象中，然后对该对象进行缓存，这样，一个对象就可以提供给多出需要使用的地方，避免大量同一对象的多次创建，降低大量内存空间的消耗。

享元模式其实是工厂方法模式的一个改进机制，享元模式同样要求创建一个或一组对象，并且就是通过工厂方法模式生成对象的，只不过享元模式为工厂方法模式增加了缓存这一功能。

前面分析了享元模式的结构与特点，下面分析它适用的应用场景。享元模式是通过减少内存中对象的数量来节省内存空间的，所以以下几种情形适合采用享元模式。

  • 系统中存在大量相同或相似的对象，这些对象耗费大量的内存资源。
  • 大部分的对象可以按照内部状态进行分组，且可将不同部分外部化，这样每一个组只需保存一个内部状态。
  • 由于享元模式需要额外维护一个保存享元的数据结构，所以应当在有足够多的享元实例时才值得使用享元模式。
JWei_7
关注
专栏目录
设计模式详解（十二）——享元模式
weixin_41951205的博客
10-23 255
一、场景问题 设计一套五子棋的程序。 二、解决方案 1、传统解决方案 1.1、解决思路 考虑到五子棋只包含黑白两种棋子，可以定义棋子类，属性包括棋子的颜色和位置。每次下棋时都新建个棋子对象，设置指定的颜色和位置。 1.2、弊端 虽然这样设计是最简单的，但是如果我们的棋盘巨大，或者棋子的基本属性很多（例如棋子的皮肤、形状等），就会导致棋子的对象创建成本较高，导致内存的浪费。 2、享元模式方案 明白了上面写法的弊端，我们考虑只创建两种棋子——黑白棋子。棋盘上的棋子展示全部共享与这两个棋子，从而减少内存的消耗。
设计模式之享元模式详解
weixin_45538589的博客
11-19 736
设计模式之享元模式详解 文章目录设计模式之享元模式详解一、什么是享元模式二、享元模式的角色组成三、享元模式应用场景四、享元模式示例五、享元模式优缺点 一、什么是享元模式 享元模式（Flyweight Pattern） 也称为轻量级模式 是对象池的一种实现。类似于线程池，线程池可以避免不停的创建和销毁对象消耗性能。减少了对象数量从而改善应用所需的对象结构的方式。其宗旨是共享细粒度对象，将多个对同一对象的访问集中起来，不必为每个访问者创建一个独立的对象，以此来降低内存的消耗，属于结构型模式。享元模式把一个对象
设计模式——享元模式详解
weixin_30470857的博客
12-31 626
0. 前言写在最前面，本人的设计模式类博文，建议先看博文前半部分的理论介绍，再看后半部分的实例分析，最后再返回来复习一遍理论介绍，这时候你就会发现我在重点处标红的用心，对于帮助你理解设计模式有奇效哦~本文原创，转载请注明出处为SEU_Calvin的博客。春运买火车票是一件疯狂的事情，同一时刻会有大量的查票请求涌向服务器，服务器必须做出应答来满足我们的购票需求。试想，这些请求包含着大量的重复，比...
JAVA设计模式之享元模式
热门推荐
一个本科小生的奋斗史
04-04 4万+
解释一下概念：也就是说在一个系统中如果有多个相同的对象，那么只共享一份就可以了，不必每个都去实例化一个对象。比如说一个文本系统，每个字母定一个对象，那么大小写字母一共就是52个，那么就要定义52个对象。如果有一个1M的文本，那么字母是何其的多，如果每个字母都定义一个对象那么内存早就爆了。那么如果要是每个字母都共享一个对象，那么就大大节约了资源。 　　在Flyweight模式中，由于要产生各种各样
C++设计模式之享元模式（Flyweight）
08-27
C++设计模式之享元模式（Flyweight）是一种结构型设计模式，主要用于解决大量相似对象的创建和操作所带来的内存负载问题。该模式的主要设计目标是通过共享对象来减少内存负载，提高系统的性能。 享元模式顾名思义...
【C#设计模式(6)——适配器模式(Adapter Pattern)】
weixin_43626218的博客
11-12 323
C#设计模式(6)——适配器模式(Adapter Pattern)适配器模式主要用于在不修改现有类的情况下，使本来不包含的类可以一起工作。
设计模式-组合模式
孟孟的博客
11-10 591
组合模式UML类图：Component抽象组件角色：所有树形结构的叶子结点和非叶子节点都需要继承该抽象角色Leaf叶子构件角色：叶子节点Composite树枝构件角色：非叶子节。
C++设计模式和编程框架两种设计元素的比较与相互关系
Joshua的专栏
11-13 970
设计模式是在软件设计中反复出现的特定问题的解决方案。它们是经过验证的、可复用的设计方案，提供了一种通用的方法来解决常见的设计问题。编程框架是一个预定义的结构，定义了应用程序的基本架构和流程。开发人员在框架的基础上进行开发，通常需要遵循框架的规则和约定。C++设计模式和编程框架都是软件设计中的重要元素，它们各自具有独特的特点和应用场景。设计模式提供了抽象的解决方案，具有很高的复用性和灵活性；而编程框架提供了具体的实现结构，提高了开发效率和一致性。
设计模式之责任链模式（Chain Of Responsibility）
liang8999的博客
11-10 935
4）职责链模式常被用在框架开发中，用来实现框架的过滤器、拦截器功能，让框架的使用者在不修改源码的情况下，添加新的过滤拦截功能。3）客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不。1）抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和。处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。并且每个类只需要处理自己该处理的工作，不能处理的传递给下一个对象。5）责任分担，每个类只需要处理自己该处理的工作，不能处理的传递给下一个对象完成，
【GeekBand】C++设计模式笔记10_Prototype_原型模式
qq_38154295的博客
11-12 399
【GeekBand】C++设计模式笔记10_Prototype_原型模式
优化C++设计模式：用模板代替虚函数与多态机制
最新发布
Where there is life, there is hope.
11-15 628
MISRA C++ 标准对类型转换和虚函数使用做出严格规定，尤其在嵌入式系统中，以确保代码的可预测性和高效性。传统设计模式中虚函数和多态性引入会增加运行时开销，增加系统负担。然而，模板编程通过编译时决策代替运行时动态绑定，可以提升性能并降低内存消耗。 本文将尝试使用C++11改进常用的几个设计模式。
怎样在软件设计中选择使用GOF设计模式
Joshua的专栏
11-14 1257
在软件设计中选择使用GOF设计模式需要综合考虑需求、问题域、模式的适用场景以及模式的优缺点。通过理解设计模式的核心思想，并结合具体的示例进行实践，可以有效地提高软件的可维护性、可扩展性和代码复用性。理解设计模式的设计意图、类之间的关联关系，以及重新设计的原因是非常重要的。通过这些要点，可以更有针对性地选择合适的模式，解决系统设计中的具体问题，提高代码的可维护性、可扩展性和灵活性。
c++设计模式之策略模式
jjjxxxhhh123的博客
11-15 335
例如，监控软件在与不同型号的交换机交互时，可能需要根据交换机的配置策略、管理需求等选择不同的操作策略。假设我们需要根据不同的网络环境选择不同的连接策略（例如，基于串口、SSH或Telnet连接设备）。Context（上下文）：使用策略的对象，持有一个对策略的引用，并委托任务给具体的策略对象。当系统需要根据不同的条件选择不同的算法或行为时，策略模式是一个理想的解决方案。Strategy（策略接口）：定义一个接口，所有的具体策略类都实现该接口。ConnectionStrategy 定义了连接的接口。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值