享元模式

结构型模式——享元（Flyweight） 目录 结构型模式——享元（Flyweight） 问题背景 解决方案 效果 缺陷 相关模式 实现 问题背景 当使用大量细粒度对象，需要提高系统性能时，考虑使用享元。现在我们要为一个RPG游戏设计装备系统，首先根据需求提取出装备类的属性，可能包括：标识符、名称、描述、装备类型、初始属性取值集合、穿戴条件、属性集合、耐久上限、当前耐久、最高强化等级、强化等级……我们会发现这些属性中，有些在同种装备中都是相同的，并且在运行时不会改变，比如名称、描述、初始属性取值集合、最高强化等级，我们把这些属性称为“静态属性”；还有一些是每个装备实例都不同的，在运行时会改变，比如属性集合、当前耐久、强化等级，我们把这些属性称为“动态属性”。 如果将静态属性和动态属性放在同一个类里，一方面会导致每个实例都维护大量相同数据，严重影响程序的性能；另一方面无法显示地区分静态属性和动态属性，容易造成混淆，尤其是这种涉及到类（class）和分类（category）两种相似概念的系统。 解决方案 把静态属性和动态属性放在同一个类中会导致运行性能低下，系统难以理解。下面使用享元，将静态属性和动态属性拆开。 增加一个类EquipmentFlyweight来存放静态属性，原本的Equipment类中的静态属性改为对EquipmentFlyweight的引用。如此一来

享元模式 享元模式： 运用共享技术有效地支持大量细粒度的对象。 享元模式可以避免大量非常相似类的开销。 如果一个应用程序使用了大量的对象，而大量的这些对象造成了很大的存储开销时就应该考虑使用；还有就是对象的大多数状态可以外部状态，如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象，此时可以考虑使用享元模式。 来源： https://www.cnblogs.com/LampsAsarum/p/12263070.html

using UnityEngine ; public class ConcreteFlyWeight : FlyWeight { public ConcreteFlyWeight ( string name ) : base ( name ) { } public override void Operation ( ) { Debug . Log ( "执行" + Name ) ; } } using UnityEngine ; public abstract class FlyWeight { public string Name ; public FlyWeight ( string name ) { Name = name ; } public abstract void Operation ( ) ; } using System . Collections . Generic ; using UnityEngine ; public class FlyWeightFactory { public Dictionary < string , FlyWeight > flyweightDic ; //key 是共享组件的名称 public FlyWeightFactory ( ) { flyweightDic = new Dictionary < string ,

一、定义 享元模式（Flyweight),运用共享技术有效的支持大量细粒度的对象。 二、示例代码 /*外部对象*/ public class User { private String name; public User(String name) { this.name = name; } public String getName() { return name; } } public abstract class WebSite { public abstract void use(User user); } public class ConcreteWebsite extends WebSite{ private String name; public ConcreteWebsite(String name) { this.name = name; } @Override public void use(User user) { System.out.println("网站名："+name+"，用户名："+user.getName()); } } import java.util.HashMap; public class WebsiteFactory { private HashMap<String, WebSite> hashMap = new HashMap();

享元(Flyweight, 『轻量级』）模式，指的是一种构造对象时对于完全相同的对象直接返回之前已经构造的对象而无需重新构造的设计模式，用于大量创建相同对象的场景，减小内存使用。享元模式的关键是享元工厂类中用于缓存享元对象的哈希表。Java的 字符串常量池 就是享元模式的典型应用。 下面用一个字符封装类 SharedCharacter 为例介绍享元模式，通过享元模式，同样的字符用同一个封装类对象，无需构造大量的字符对象。 驱动类：Main.java public class Main { public static void main(String[] args) { SharedCharacter scA = SharedCharacterFactory.getSharedCharacter('a'); SharedCharacter scB = SharedCharacterFactory.getSharedCharacter('b'); SharedCharacter scA1 = SharedCharacterFactory.getSharedCharacter('a'); System.out.println("scA: " + scA + ", scB: " + scB + ", scA1: " + scA1); // scA: a, scB: b, scA1: a

　享元模式是设计模式中少数几个以提高系统性能为目的的设计模式。他的核心思想是： 如果一个系统中存在多个相同的对象，那么只需共享一份对象的拷贝，而不必为每一次使用都创建新的对象。 享元模式的主要优点是：相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。 其主要缺点是： 为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。 读取享元模式的外部状态会使得运行时间稍微变长。 #include <iostream> #include <list> #include <string> #include <map> using namespace std; class WebSite //抽象的网站 { public: virtual void use() = 0;//预留接口实现功能 }; class ConcreteWebSite :public WebSite //具体的共享网站 { private: string name; public: ConcreteWebSite(string name)//实例化 { this->name = name; } void use() { cout << "网站分类: " << name << endl; } }; //不共享的网站 class UnShareWebSite :

享元模式就是 如果有很多个一样或者相似的对象；提高它的复用性；节省内存（ 可能存在 时间换空间上的问题，这个避免不了）； 核心：1. 共享的方式支持大量细粒度的复用； 2. 享元 做到共享的关键 一是 内部状态（共享的状态） 二是外部状态（不可共享的状态） ******************** 实现结构： 1. 享元工厂类 2，抽象享元类 3，具体享元类 4，非共享享元类 ******************** 代码实现： 坐标类 package FlyWeight; // 坐标类 public class Coordinate { private int x,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; } public Coordinate(int x, int y) { super(); this.x = x; this.y = y; } } 享元类 package FlyWeight; /** * * 享元类接口 * * */ public interface ChessFlyWeight { void setColor

前面在写到多线程的文章的时候，一直想写一篇关于线程池等一系列的文章，做一下记录，本篇博客记录一下 设计模式 中享元模式的设计思想，以及使用享元模式的实现案例——线程池，以及线程池的简化版——任务(task) 享元模式 在软件开发过程中，如果我们需要重复使用某个对象的时候，重复的去new这样一个对象，我们在内存中就会多次的去申请内存空间了，这样，可能会出现内存使用越来越多的情况。 如果让我们解决这个问题，会不会这样想：“既然是同一个对象，能不能只创建一个对象，然后下次需要再创建这个对象的时候，让它直接用已经创建好的对象就好了”，也就是说--让一个对象共享！ 这种实现方式有点类似排版印刷术，将所有的字先提前印刷好，需要哪个字直接拿过来用，就不用每次打印字的时候再重新造一个字的模板了，这就是我理解的享元模式的思想。 享元模式的正式定义： 运用共享技术有效的支持大量细粒度的对象，享元模式可以避免大量相类似的开销，在软件开发中如果需要生成大量细粒度的类实例来表示数据，如果这些实例除了几个参数外基本都是相同的，这个时候就可以使用享元模式。如果把这些参数(指的是这是实例不同的参数，比如：排版印刷的时候每个字的位置)移动到类的外面，在调用方法时把他们传递进来，这样就通过共享数据，减少了单个实例的数目(这个也是享元模式的实现要领)，我们把类实例外面的参数称之为享元对象的外部状态

前面在写到多线程的文章的时候，一直想写一篇关于线程池等一系列的文章，做一下记录，本篇博客记录一下设计模式中享元模式的设计思想，以及使用享元模式的实现案例——线程池，以及线程池的简化版——任务(task) 享元模式 在软件开发过程中，如果我们需要重复使用某个对象的时候，重复的去new这样一个对象，我们在内存中就会多次的去申请内存空间了，这样，可能会出现内存使用越来越多的情况。 如果让我们解决这个问题，会不会这样想：“既然是同一个对象，能不能只创建一个对象，然后下次需要再创建这个对象的时候，让它直接用已经创建好的对象就好了”，也就是说--让一个对象共享！ 这种实现方式有点类似排版印刷术，将所有的字先提前印刷好，需要哪个字直接拿过来用，就不用每次打印字的时候再重新造一个字的模板了，这就是我理解的享元模式的思想。 享元模式的正式定义： 运用共享技术有效的支持大量细粒度的对象，享元模式可以避免大量相类似的开销，在软件开发中如果需要生成大量细粒度的类实例来表示数据，如果这些实例除了几个参数外基本都是相同的，这个时候就可以使用享元模式。如果把这些参数(指的是这是实例不同的参数，比如：排版印刷的时候每个字的位置)移动到类的外面，在调用方法时把他们传递进来，这样就通过共享数据，减少了单个实例的数目(这个也是享元模式的实现要领)，我们把类实例外面的参数称之为享元对象的外部状态

前面在写到多线程的文章的时候，一直想写一篇关于线程池等一系列的文章，做一下记录，本篇博客记录一下设计模式中享元模式的设计思想，以及使用享元模式的实现案例——线程池，以及线程池的简化版——任务(tesk) 享元模式 在软件开发过程中，如果我们需要重复使用某个对象的时候，重复的去new这样一个对象，我们在内存中就会多次的去申请内存空间了，这样，可能会出现内存使用越来越多的情况。 如果让我们解决这个问题，会不会这样想：“既然是同一个对象，能不能只创建一个对象，然后下次需要再创建这个对象的时候，让它直接用已经创建好的对象就好了”，也就是说--让一个对象共享！ 这种实现方式有点类似排版印刷术，将所有的字先提前印刷好，需要哪个字直接拿过来用，就不用每次打印字的时候再重新造一个字的模板了，这就是我理解的享元模式的思想。 享元模式的正式定义： 运用共享技术有效的支持大量细粒度的对象，享元模式可以避免大量相类似的开销，在软件开发中如果需要生成大量细粒度的类实例来表示数据，如果这些实例除了几个参数外基本都是相同的，这个时候就可以使用享元模式。如果把这些参数(指的是这是实例不同的参数，比如：排版印刷的时候每个字的位置)移动到类的外面，在调用方法时把他们传递进来，这样就通过共享数据，减少了单个实例的数目(这个也是享元模式的实现要领)，我们把类实例外面的参数称之为享元对象的外部状态