设计模式-享元模式(FlyWeight-Pattern)

设计模式 -- 享元模式(Flyweight Pattern) 使用共享对象可以有效的支持大量的细粒度对象。 应用场景 主要目的是实现对象的共享,即共享池,当系统中对象多的时候可以减少内存的开销,通常与工厂模式一起使用。例如:缓存,对象池;Android中: Message.obtain通过重用Message对象来避免大量的Message对象被频繁的创建和销毁。 FlyWeightFactory负责创建和管理享元单元,当一个客户端请求时,工厂需要检查当前对象池中是否有符合条件的对象,如果有,就返回已经存在的对象,如果没有,则创建一个新对象,FlyWeigh 阅读详情

设计模式-享元模式(FlyWeight-Pattern)

一、简介:

  • 运用共享技术有效地支持大量细粒度的对象
  • 共享的对象:已经存在的对象。
  • 享元模式的意图是复用对象,节省内存;
  • 也叫蝇量模式;
  • 前提是享元对象是不可变对象。
  • 作用:通过共享已存在的对象,大幅度减少需要创建的对象数量、避免大量相似类的开销,从而提高系统资源的利用率。
  • 本质:保存共享对象,降低内存消耗。
  • 优点:相同的对象只要保存一份,降低了系统中对象的数量,降低了系统中细粒度对象给内存带来的压力。
  • 缺点:
    • 需要将不能共享的对象外部化,一定程度上增加了程序的复杂性
    • 读取享元状态外部状态使得运行时间稍微变长
  • 两个定义:细粒度、共享对象,因为要求细粒度,所以使得对象数量多且性质相近,此时我们就将这些对象的信息分为两个部分:内部状态和外部状态。
    • 内部状态:对象共享的信息,存储在享元信息内部,不再改变,可以共享
    • 外部状态:对象得以依赖的一个标记,随环境的改变而改变,不可共享。
      • 比如,连接池中的连接对象,保存在连接对象中的用户名、密码、连接URL等信息,在创建对象的时候就设置好了,不会随环境的改变而改变,这些为内部状态。
      • 而当每个连接要被回收利用时,我们需要将它标记为可用状态,这些为外部状态。

二、结构与内存

2.1、结构(主要角色):

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

2.2、类图:

在这里插入图片描述

  • FlyWeight是抽象的享元角色,他是产品的抽象类,同时定义出对象的外部状态和内部状态
  • ConcreteFlyWeight 是具体的享元角色,是具体的产品类,实现抽象角色定义相关业务
  • UnSharedConcreteFlyWeight 是不可共享的角色,一般不会出现在享元工厂
  • FlyWeightFactory 享元工厂类,用于构建一个池 容器(集合),同时 提供从池中获取对象方法

三、测试

3.1、demo1:

package top.jkxljc.flyweight.demo2;
import java.util.HashMap;
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;
    }
}

3.2、五子棋案例:

五子棋同围棋一样,包含多个“黑”或“白”颜色的棋子,故可用享元模式。

  • 棋子(ChessPieces)类是抽象享元角色,它包含了一个落子的 DownPieces(Graphics g,Point pt) 方法;
  • 白子(WhitePieces)和黑子(BlackPieces)类是具体享元角色,它实现了落子方法;
  • Point 是非享元角色,它指定了落子的位置;
  • WeiqiFactory 是享元工厂角色,它通过 ArrayList 来管理棋子,并且提供了获取白子或者黑子的 getChessPieces(String type) 方法;
  • 客户类(Chessboard)利用 Graphics 组件在框架窗体中绘制一个棋盘,并实现 mouseClicked(MouseEvent e) 事件处理方法,该方法根据用户的选择从享元工厂中获取白子或者黑子并落在棋盘上。
    在这里插入图片描述
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;
        }
    }
}

四、应用场景与扩展:

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

4.1、应用场景:

减少内存中对象的数量来节省内存空间

  1. 系统中存在大量相同或相似的对象,这些对象耗费大量的内存资源。
  2. 大部分的对象可以按照内部状态进行分组,且可将不同部分外部化,这样每一个组只需保存一个内部状态。
  3. 由于享元模式需要额外维护一个保存享元的数据结构,所以应当在有足够多的享元实例时才值得使用享元模式。

4.2、扩展:

  • 单纯享元模式,模式中的所有的具体享元类都是可以共享的,不存在非共享的具体享元类
  • 复合享元模式,模式中的有些享元对象是由一些单纯享元对象组合而成的,它们就是复合享元对象。虽然复合享元对象本身不能共享,但它们可以分解成单纯享元对象再被共享。

五、对比:

https://www.jianshu.com/p/03a4d1223369

  • 享元模式跟单例的区别
    • 在单例模式中,一个类只能创建一个对象,而在享元模式中,一个类可以创建多个对象,每个对象被多处代码引用共享。
    • 实际上,享元模式有点类似于之前讲到的单例的变体:多例。
    • 区别两种设计模式,不能光看代码实现,而是要看设计意图,也就是要解决的问题。尽管从代码实现上来看,享元模式和多例有很多相似之处,但从设计意图上来看,它们是完全不同的。
      • 应用享元模式是为了对象复用,节省内存,
      • 应用多例模式是为了限制对象的个数。
  • 享元模式跟缓存的区别
    • 在享元模式的实现中,我们通过工厂类来“缓存”已经创建好的对象。这里的“缓存”实际上是“存储”的意思,跟我们平时所说的“数据库缓存”“CPU 缓存”“MemCache 缓存”是两回事。我们平时所讲的缓存,主要是为了提高访问效率,而非复用。
  • 享元模式跟对象池的区别
    • 对象池、连接池(比如数据库连接池)、线程池等也是为了复用,
    • 像 C++ 这样的编程语言,内存的管理是由程序员负责的。为了避免频繁地进行对象创建和释放导致内存碎片,我们可以预先申请一片连续的内存空间,也就是这里说的对象池。每次创建对象时,我们从对象池中直接取出一个空闲对象来使用,对象使用完成之后,再放回到对象池中以供后续复用,而非直接释放掉。
    • 虽然对象池、连接池、线程池、享元模式都是为了复用,但是,如果我们再细致地看复用”这个字眼的话,对象池、连接池、线程池等池化技术中的“复用”和享元模式中的“复用”实际上是不同的概念。
    • 池化技术中的“复用”可以理解为“重复使用”,主要目的是节省时间(比如从数据库池中取一个连接,不需要重新创建)。在任意时刻,每一个对象、连接、线程,并不会被多处使用,而是被一个使用者独占,当使用完成之后,放回到池中,再由其他使用者重复利用。
    • 享元模式中的“复用”可以理解为“共享使用”,在整个生命周期中,都是被所有使用者共享的,主要目的是节省空间。
LLMOps的崛起:如何利用Langfuse和Opik构建高效的模型监控与评估体系 本文探讨了LLMOps的崛起,详细介绍了如何利用Langfuse和Opik构建高效的模型监控与评估体系。通过开源工具Langfuse的全景监控方案和Opik的三层评估体系,帮助AI工程团队实现大语言模型的全生命周期管理,提升模型性能和迭代效率。文章还提供了实战技巧和工具链集成方案,助力企业优化AI应用。 阅读详情

相关推荐

SecureCRT多种配色方案配置文件

位置 C:\Users%USERNAME%\AppData\Roaming\VanDyke\Config\Global.ini S:"SecureCRT Tab State"=1,1,1,0,0 S:"SecureFX Local Tab State"=1,-1,200 D:"Max Chat Window History"=000000c8 D:"Active Window Alpha Transparency"=000000f0 D:"Save Keymaps As Unicode"=00000000

神棍之路 3713

【每日学设计模式——结构型模式】享元模式

菜鸟教程链接:享元模式 概念 享元模式类似于工厂+缓存的模式,当创建对象的时候,通过条件判断缓存中有没有对应对象,如果有直接取出缓存,如果没有则新建并放入缓存中,再返回。 优缺点 优点: 创建对象时利用了缓存,提升了响应速度。 节约了资源。 缺点: 提升了系统的复杂度。 适用场景 缓存场景,例如校验token场景,通过用户ID获取用户信息的地方。任何系统大量用到重复或相似对象,并有确定的条件区分的地方,都可以用的该设计模式。 示例代码 import java.util.HashMap; publ

lunatic__的博客 256

MicroPython跨平台移植实战:从源码解析到STM32+FreeRTOS部署

本文详细解析了MicroPython的跨平台移植实战,重点介绍了如何将其从源码开始,成功部署到STM32微控制器并运行于FreeRTOS实时操作系统。内容涵盖源码结构解析、编译环境搭建、内存管理协调、FreeRTOS任务集成、数学库(math)启用与优化,以及自定义模块开发等核心步骤,为开发者提供了一套完整的、可操作的嵌入式Python移植方案。

vodka的博客 1014

设计模式之享元模式

享元模式 1. 介绍 尚硅谷Java设计模式(图解+框架源码剖析) 五分钟设计模式 - 享元模式 菜鸟教程 - 享元模式 1.1 描述和作用 享元漠式(Flyweight Pattern)用共享技术有效地支持大量细粒度的对象 “享”表示共享,“元”表示对象 常用于系统底层开发,解决系统的性能问题。像数据库连接池,里面都是创建好的连接对象,在这些连接对象中有我们需要的则直接拿来用,避免重新创建,如果没有我们需要的,则创建一个 享元模式能够解决重复对象的内存浪费的问题, 当系统中有大量相似对象,需要缓冲池时。

mrhanzhou5273的博客 231

Windows版MySQL8.4.2LTS解压直用(下载免安装-绿色-项目打包直接使用-含卸载)

安装前运行微软常用运行库全集(也可能称为依赖)关于MySQL8中相关参数配置,可通过。选择8.5.2LTS长期服务版。选中密码,右键会直接复制。

xzzteach的博客 1442

车载以太网抓包实战:100BASE-T1/1000BASE-T1高效监控方案解析

本文深入解析了车载以太网100BASE-T1/1000BASE-T1的高效抓包监控方案。针对智能汽车开发中的故障排查与性能测试需求,详细对比了交换机镜像、TAP分流和捕获模块三大主流方案的原理、核心优势与适用场景,并提供了基于实战经验的选型指南与操作避坑要点,帮助工程师精准定位网络问题。

desk3的博客 430

设计模式-享元模式

所谓“享元”,顾名思义就是被共享的单元。享元模式的意图是复用对象,节省内存,前提是享元对象是不可变对象。需要注意的是,享元模式对 JVM 的垃圾回收并不友好。因为享元工厂类一直保存了对享元对象的引用,这就导致享元对象在没有任何代码使用的情况下,也并不会被 JVM 垃圾回收机制自动回收掉。因此,在某些情况下,如果对象的生命周期很短,也不会被密集使用,利用享元模式反倒可能会浪费更多的内存。

码农界的菜鸟 220

自锁电路设计

Hi,uu们,是不是经常要用到自锁电路,通常不是使用555芯片就是用比较器来做自锁,今天我们来简单看下自锁电路的设计.图1采用了比较器构建了一个自锁电路,采用低电平复位,当需要复位的时候志需要将反向端的二极管拉低一下即可,免去 三极管控制同相端和电源短接的麻烦。图1:比较器构建的自锁电路也可以使用555去构建,如下图2所示.图2:使用555构建的自锁电路工作原理见555的真值表,真值表如表1所示.表1:555电路真值表相对来说555还是比较贵,所以我就想能不能有个便宜的方法做个自锁电路,构建电路如下图3所示

weixin_43884675的博客 7078

【设计模式】享元(Flyweight)模式实例

系列文章目录 第五章 结构模式(下) 目录 系列文章目录 🌍前言 一、🌍外观(Facade)模式是什么? 二、🌍外观(Facade)模式的优缺点 三、🌍外观(Facade)模式的结构 四、🌍实例演示 1.🌕实例概述 2.🌕代码演示 3.🌕实验结果 总结 🌍前言 设计模式,又称为软件设计模式,是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。 学习设计模式可以提高程序员的思维能力、编程能力和设计能力,使程序设计...

weixin_51167671的博客 1185

Android存储空间不足下,APP出现奔溃等情况

版权声明:本文为博主原创文章,未经博主允许不得转载。 1. 问题起因     实时录制视频,使用getExternalCacheDir()函数返回的路径作为文件缓存区 2. 问题产生     系统在空间不足的情况下第一清除getExternalCacheDir和getCache文件下的缓存,导致正在录制的视频出现Error。 3. 解决方案     第一

OverseasAndroid的博客 4161

CSR-DCF视频目标跟踪源码运行笔记

论文基本信息 论文标题:Discriminative Correlation Filter with Channel and Spatial Reliability 论文作者:Alan Lukezic等 论文出处:CVPR 2017 文章链接:https://arxiv.org/abs/1611.08461 补充材料:https://www.semanticscholar.org/paper/D...

越野者的博客 3401

深入理解享元模式

面向对象技术可以很好地解决一些灵活性或可扩展性问题,但在很多情况下需要在系统中增加类和对象的个数。当对象数量太多时,将导致运行代价过高,带来性能下降等问题。享元模式通过共享技术实现相同或相似对象的重用提高系统资源的利用率。本文首先阐述了享元模式要解决的问题和解决问题的理念,然后从实现角度重点说明了该模式的本质,并进一步给出了其所包含的角色和组织结构。最后,给出了共享模式的应用实例和使用场景。

Rico's Blogs 2万+

双重分组进位跳跃进位链

跳跃进位链

qq_62260432的博客 942

23种设计模式——享元模式(Flyweight Pattern)

本文介绍了23种经典设计模式之——享元模式(Flyweight Pattern)的使用及说明

Meteors.的博客 1345

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

【设计模式】——享元模式(Flyweight Pattern)

享元模式(Flyweight Pattern)是一种对象结构型模式,它通过共享已经存在的对象来减少内存使用量和提高系统性能。享元模式特别适用于那些创建大量相似对象而导致内存消耗过大的场景。本文将详细介绍享元模式在C++中的实现和应用。

J^T的博客 2696

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

设计模式-10享元模式Flyweight Pattern

摘要:享元模式是一种结构型设计模式,通过共享相似对象来减少内存消耗和提高性能。它适用于系统中有大量相似对象且大多数状态可外部化的场景。模式包含享元接口、具体享元类、享元工厂和客户端四个主要部分。文中提供了两种实现示例:文本编辑器中的字符共享和图形渲染中的树对象共享,展示了如何通过工厂管理共享对象,显著减少实际创建的对象数量。

d3y1`5 81_09 962

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

23种设计模式之享元模式(Flyweight Pattern)

本篇文章将23种设计模式中的享元模式,此篇文章为一天学习一个设计模式系列文章,后面会分享其他模式知识。

小威的博客 2万+

设计模式-享元模式-Flyweight Pattern

创建一个接口或抽象类,定义享元对象的公共接口。

wesigj的博客 1669

设计模式-享元模式(Flyweight Pattern)

享元模式 定义 Use sharing to support large numbers of fine-grained objects efficiently. 使用共享对象可有效地支持大量的细粒度的对象。 类型 结构型。 适用场景 在对象(相同或相似的对象)足够多的时候,而创建这些对象造成了很大的系统开销时,应该考虑使用享元模式。 享元有被频繁使用的场景,才有使用享元模式的价值,因为,在...

kaven 4498

Android设计模式之享元模式(Flyweight Pattern)

一 享元模式介绍:1.1 使用享元模式有什么好处? 享元模式是对象池的一种实现,主要目的是用来尽可能减少内存使用量。适合于存在大量重复对象的场景,来缓存可共享的对象,达到对象共享,避免创建过多对象的效果,这样可以提升性能。1.2 关于享元对象? 享元对象中的部分状态可以共享,可以共享的状态为内部状态(内蕴状态),内部状态不会随环境变化,不可共享的状态是外部状态(外蕴状态),外部状态随外部环境

happy_horse的博客 1989

设计模式之享元模式(Flyweight Design Pattern)

享元模式是八种结构型模式之一,享元就是共享单元(元素)的意思,可以理解是共享对象。享元模式的用途就是复用对象,节省内存。 如何使用享元模式,用棋牌室举例。 斗地主相信很多人都玩过,一副版,黑红花方四色,每一色都有从2到A的13张牌,加上大小王,共有54张牌。假如一张牌就是一个对象,一张桌子就要54个对象;一个牌室300张桌子;一个服务器有50个牌室;这样的服务器可能又有200个。那这样的对象就是54*300*50*200=162000000个。 ...

xjj1314的专栏 351

设计模式:享元模式(Flyweight Pattern)

享元模式是一种结构型设计模式, 它摒弃了在每个对象中保存所有数据的方式, 通过共享多个对象所共有的相同状态, 让你能在有限的内存容量中载入更多对象。

TechNomad的博客 853

秒懂设计模式之享元模式(Flyweight Pattern)

[版权申明] 非商业目的注明出处可自由转载 博文地址: 出自:shusheng007 设计模式汇总篇,一定要收藏: 永不磨灭的设计模式(有这一篇真够了,拒绝标题党) 文章目录概述类型难度定义使用场景UML类图实例第一步,定义一个共享对象通用的接口第二步,实现需要共享的对象类第三步,共享对象工厂第四步,客户端使用技术要点总结优缺点优点缺点总结 概述 也许你会觉得享元模式比较陌生,但是相信在你的软件开发生涯中应该不知不觉的用了很多次,只是你没有总结。例例如你肯定用到过缓存,用到过对象池… 不知道作为IT猿的.

ShuSheng007的程序人生 2340

C++设计模式——享元模式(flyweight pattern)

# 一、原理讲解 ## 1.1意图 运用共享技术有效地支持大量细粒度的对象。 ## 1.2应用场景 - 一个程序中使用了大量的对象; - 完全由于使用大量的对象造成很大的存储开销; - 对象的大多数状态都可变为外部状态; - 如果删除对象的外部状态,那么可以用相对较少的共享对象取代很多组对象; - 应用程序不依赖于对象标识。 ## 1.3结构图(UML图) ![享元模式UML结构图](https://img-blog.csdnimg.cn/20200902222642384.jpg?x-oss-

净无邪博客 551

Java设计模式——享元模式【Flyweight Pattern】

Java设计模式、享元模式、Flyweight Pattern

scorpio的博客 823

【设计模式】享元模式(Flyweight Pattern)

享元模式(Flyweight Pattern)又被称作轻量级模式、蝇量模式,它经典的体现就是对象池。享元模式的根本目的就是"共享单元",让对象能够共享复用,就像共享单车一样,路人甲(客户程序A)骑完路人丙(客户程序B)用,以此减少内存占用。

櫆溟的博客 487
上一篇: CountDownLatch学习
下一篇: 设计模式-观察者模式
ADCQprogrammer
博客等级 码龄7年 4粉丝 21原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值