设计模式之享元模式(Flyweight)摘录

时间:2022-09-22 23:21:59

23种GOF设计模式一般分为三大类:创建型模式、结构型模式、行为模式。

创建型模式抽象了实例化过程,它们帮助一个系统独立于怎样创建、组合和表示它的那些对象。一个类创建型模式使用继承改变被实例化的类,而一个对象创建型模式将实例化托付给还有一个对象。创建型模式有两个不断出现的主旋律。第一,它们都将关于该系统使用哪些详细的类的信息封装起来。第二,它们隐藏了这些类的实例是怎样被创建和放在一起的。整个系统关于这些对象所知道的是由抽象类所定义的接口。因此,创建型模式在什么被创建,谁创建它,它是怎样被创建的,以及何时创建这些方面给予了非常大的灵活性。它们同意用结构和功能区别非常大的“产品”对象配置一个系统。配置能够是静态的(即在编译时指定),也能够是动态的(在执行时)。

结构型模式涉及到怎样组合类和对象以获得更大的结构。结构型类模式採用继承机制来组合接口或实现。结构型对象模式不是对接口和实现进行组合,而是描写叙述了怎样对一些对象进行组合,从而实现新功能的一些方法。由于能够在执行时刻改变对象组合关系,所以对象组合方式具有更大的灵活性,而这样的机制用静态类组合是不可能实现的。

行为模式涉及到算法和对象间职责的分配。行为模式不仅描写叙述对象或类的模式,还描写叙述它们之间的通信模式。这些模式刻画了在执行时难以跟踪的复杂的控制流。它们将用户的注意力从控制流转移到对象间的联系方式上来。行为类模式使用继承机制在类间分派行为。行为对象模式使用对象复合而不是继承。一些行为对象模式描写叙述了一组对等的对象怎样相互协作以完毕当中任一个对象都无法单独完毕的任务。

创建型模式包含:1、FactoryMethod(工厂方法模式);2、Abstract Factory(抽象工厂模式);3、Singleton(单例模式);4、Builder(建造者模式、生成器模式);5、Prototype(原型模式).

结构型模式包含:6、Bridge(桥接模式);7、Adapter(适配器模式);8、Decorator(装饰模式);9、Composite(组合模式);10、Flyweight(享元模式);11、Facade(外观模式);12、Proxy(代理模式).

行为模式包含:13、TemplateMethod(模板方法模式);14、Strategy(策略模式);15、State(状态模式);16、Observer(观察者模式);17、Memento(备忘录模式);18、Mediator(中介者模式);19、Command(命令模式);20、Visitor(訪问者模式);21、Chain of Responsibility(责任链模式);22、Iterator(迭代器模式);23、Interpreter(解释器模式).

Factory Method:定义一个用于创建对象的接口,让子类决定将哪一个类实例化。Factory Method使一个类的实例化延迟到其子类。

Abstract Factory:提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们详细的类。

Singleton:保证一个类仅有一个实例,并提供一个訪问它的全局訪问点。

Builder:将一个复杂对象的构建与它的表示分离,使得相同的构建过程能够创建不同的表示。

Prototype:用原型实例指定创建对象的种类,而且通过拷贝这个原型来创建新的对象。

Bridge:将抽象部分与它的实现部分分离,使它们都能够独立地变化。

Adapter:将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类能够一起工作。

Decorator:动态地给一个对象加入一些额外的职责。就扩展功能而言, Decorator模式比生成子类方式更为灵活。

Composite:将对象组合成树形结构以表示“部分-总体”的层次结构。Composite使得客户对单个对象和复合对象的使用具有一致性。

Flyweight:运用共享技术有效地支持大量细粒度的对象。

Facade:为子系统中的一组接口提供一个一致的界面, Facade模式定义了一个高层接口,这个接口使得这一子系统更加easy使用。

Proxy:为其它对象提供一个代理以控制对这个对象的訪问。

Template Method:定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。Template Method使得子类能够不改变一个算法的结构就可以重定义该算法的某些特定步骤。

Strategy:定义一系列的算法,把它们一个个封装起来, 而且使它们可相互替换。本模式使得算法的变化可独立于使用它的客户。

State:同意一个对象在其内部状态改变时改变它的行为。对象看起来似乎改动了它所属的类。

Observer:定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,全部依赖于它的对象都得到通知并自己主动刷新。

Memento:在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可将该对象恢复到保存的状态。

Mediator:用一个中介对象来封装一系列的对象交互。中介者使各对象不须要显式地相互引用,从而使其耦合松散,而且能够独立地改变它们之间的交互。

Command:将一个请求封装为一个对象,从而使你可用不同的请求对客户进行參数化;对请求排队或记录请求日志,以及支持可取消的操作。

Visitor:表示一个作用于某对象结构中的各元素的操作。它使你能够在不改变各元素的类的前提下定义作用于这些元素的新操作。

Chain of Responsibility:为解除请求的发送者和接收者之间耦合,而使多个对象都有机会处理这个请求。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它。

Iterator:提供一种方法顺序訪问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。

Interpreter:给定一个语言, 定义它的文法的一种表示,并定义一个解释器, 该解释器使用该表示来解释语言中的句子。

Flyweight:(1)、意图: 运用共享技术有效地支持大量细粒度的对象。

(2)、Flyweight是一个共享对象,它能够同一时候在多个场景(context)中使用,而且在每一个场景中flyweight都能够作为一个独立的对象----这一点与非共享对象的实例没有区别。Flyweight模式对那些通常由于数量太大而难以用对象来表示的概念或实体进行建模。

(3)、适用性:当一下情况都成立时使用Flyweight模式:A、一个应用程序使用了大量对象;B、全然由于使用大量的对象,造成非常大的存储开销;C、对象的大多数状态都可变为外部状态;D、假设删除对象的外部状态,那么能够用相对较少的共享对象代替非常大组对象;E、应用程序不依赖于对象标识。由于Flyweight对象能够被共享,对于概念上明显有别的对象,标识測试将返回真值。

(4)、注意事项:A、删除外部状态:该模式的可用性在非常大程度上取决于是否easy识别外部状态并将它从共享对象中删除。B、管理共享对象:由于对象是共享的,用户不能直接对它进行实例化,因此Flyweight-Factory能够帮助用户查找某个特定的Flyweight对象。

(5)、相关模式:Flyweight模式通常和Composite模式结合起来,用共享叶节点的有向无环图实现一个逻辑上的层次结构。通常,最好用Flyweight实现State和Strategy对象。

运用共享技术有效地支持大量细粒度的对象(对于C++来说就是共用一个内存块,对象指针指向同一个地方)。假设一个应用程序使用了大量的对象,而这些对象造成了非常大的存储开销就应该考虑使用。还有就是对象的大多数状态能够外部状态,假设删除对象的外部状态,那么能够用较少的共享对象代替多组对象,此时能够考虑使用享元。

Flyweight模式在实现过程中主要是要为共享对象提供一个存放的”仓库”(对象池)。

演示样例代码1:

#include <string>
#include <vector>
#include <iostream> using namespace std; //抽象的站点
class WebSite
{
public:
virtual void Use() = 0;
}; //详细的共享站点
class ConcreteWebSite : public WebSite
{
private:
string name;
public:
ConcreteWebSite(string strName)
{
name = strName;
} virtual void Use()
{
cout<<"站点分类:"<<name<<endl;
}
}; //不共享的站点
class UnShareWebSite : public WebSite
{
private:
string name;
public:
UnShareWebSite(string strName)
{
name = strName;
} virtual void Use()
{
cout<<"不共享的站点:"<<name<<endl;
}
}; //站点工厂类,用于存放共享的WebSite对象
class WebFactory
{
private:
vector<WebSite*> websites;
public:
WebSite* GetWeb()
{
vector<WebSite*>::iterator p = websites.begin();
return *p;
} WebFactory()
{
websites.push_back(new ConcreteWebSite("測试"));
}
}; //client
int main()
{
WebFactory* f = new WebFactory();
WebSite* ws = f->GetWeb();
ws->Use(); WebSite* ws2 = f->GetWeb();
ws2->Use(); /*result
站点分类:測试
站点分类:測试
*/ return 0;
}

演示样例代码2:

Flyweight.h:

#ifndef _FLYWEIGHT_H_
#define _FLYWEIGHT_H_ #include <string>
using namespace std; class Flyweight
{
public:
virtual ~Flyweight();
virtual void Operation(const string& extrinsicState);
string GetIntrinsicState();
protected:
Flyweight(string intrinsicState);
private:
string _intrinsicState;
}; class ConcreteFlyweight : public Flyweight
{
public:
ConcreteFlyweight(string intrinsicState);
~ConcreteFlyweight();
void Operation(const string& extrinsicState);
protected:
private:
}; #endif//~_FLYWEIGHT_H_

Flyweight.cpp:

#include "Flyweight.h"
#include <iostream>
using namespace std; Flyweight::Flyweight(string intrinsicState)
{
this->_intrinsicState = intrinsicState;
} Flyweight::~Flyweight()
{ } void Flyweight::Operation(const string& extrinsicState)
{ } string Flyweight::GetIntrinsicState()
{
return this->_intrinsicState;
} ConcreteFlyweight::ConcreteFlyweight(string intrinsicState) : Flyweight(intrinsicState)
{
cout<<"ConcreteFlyweight Build ..."<<intrinsicState<<endl;
} ConcreteFlyweight::~ConcreteFlyweight()
{ } void ConcreteFlyweight::Operation(const string& extrinsicState)
{
cout<<"ConcreteFlyweight: ["<<this->GetIntrinsicState()<<"] ["<<extrinsicState<<"]"<<endl;
}

FlyweightFactory.h:

#ifndef _FLYWEIGHTFACTORY_H_
#define _FLYWEIGHTFACTORY_H_ #include "Flyweight.h"
#include <string>
#include <vector>
using namespace std; class FlyweightFactory
{
public:
FlyweightFactory();
~FlyweightFactory();
Flyweight* GetFlyweight(const string& key);
protected:
private:
vector<Flyweight*> _fly;
}; #endif//~_FLYWEIGHTFACTORY_H_

FlyweightFactory.cpp:

#include "FlyweightFactory.h"
#include <iostream>
#include <string>
#include <cassert> using namespace std; FlyweightFactory::FlyweightFactory()
{ } FlyweightFactory::~FlyweightFactory()
{ } Flyweight* FlyweightFactory::GetFlyweight(const string& key)
{
vector<Flyweight*>::iterator it = _fly.begin(); for (; it != _fly.end(); it ++) {
if ((*it)->GetIntrinsicState() == key) {
cout<<"already created by users ..."<<endl;
return *it;
}
} Flyweight* fn = new ConcreteFlyweight(key);
_fly.push_back(fn); return fn;
}

main.cpp:

#include "Flyweight.h"
#include "FlyweightFactory.h"
#include <iostream> using namespace std; int main()
{
FlyweightFactory* fc = new FlyweightFactory();
Flyweight* fw1 = fc->GetFlyweight("hello");
Flyweight* fw2 = fc->GetFlyweight("world!");
Flyweight* fw3 = fc->GetFlyweight("hello"); /*result
ConcreteFlyweight Build ...hello
ConcreteFlyweihgt Build ...world!
already created by users ...
*/ return 0;
}

享元模式结构图:

设计模式之享元模式(Flyweight)摘录

參考文献:

1、《大话设计模式C++》

2、《设计模式精解----GoF23种设计模式解析》

3、《设计模式----可复用面向对象软件的基础》

设计模式之享元模式(Flyweight)摘录的更多相关文章

  1. 乐在其中设计模式&lpar;C&num;&rpar; - 享元模式&lpar;Flyweight Pattern&rpar;

    原文:乐在其中设计模式(C#) - 享元模式(Flyweight Pattern) [索引页][源码下载] 乐在其中设计模式(C#) - 享元模式(Flyweight Pattern) 作者:weba ...

  2. 设计模式-11享元模式&lpar;Flyweight Pattern&rpar;

    1.模式动机 在面向对象程序设计过程中,有时会面临要创建大量相同或相似对象实例的问题.创建那么多的对象将会耗费很多的系统资源,它是系统性能提高的一个瓶颈. 享元模式就是把相同或相似对象的公共部分提取出 ...

  3. 二十四种设计模式:享元模式&lpar;Flyweight Pattern&rpar;

    享元模式(Flyweight Pattern) 介绍运用共享技术有效地支持大量细粒度的对象. 示例有一个Message实体类,某些对象对它的操作有Insert()和Get()方法,现在要运用共享技术支 ...

  4. 【UE4 设计模式】享元模式 Flyweight Pattern

    概述 描述 运用共享技术有效地支持大量细粒度对象的复用.系统只使用少量的对象,而这些对象都很相似,状态变化很小,可以实现对象的多次复用. 由于享元模式要求能够共享的对象必须是细粒度对象,因此它又称为轻 ...

  5. &lbrack;设计模式&rsqb; 11 享元模式 Flyweight

    转 http://blog.csdn.net/wuzhekai1985/article/details/6670298 问题 在面向对象系统的设计何实现中,创建对象是最为常见的操作.这里面就有一个问题 ...

  6. 设计模式 笔记 享元模式 Flyweight

    //---------------------------15/04/20---------------------------- //Flyweight 享元模式------对象结构型模式 /* 1 ...

  7. 【设计模式】—— 享元模式Flyweight

    前言:[模式总览]——————————by xingoo 模式意图 享元模式,也叫[轻量级模式]或者[蝇量级模式].主要目的就是为了减少细粒度资源的消耗.比如,一个编辑器用到大量的字母数字和符号,但是 ...

  8. 结构型设计模式之享元模式&lpar;Flyweight&rpar;

    结构 意图 运用共享技术有效地支持大量细粒度的对象. 适用性 一个应用程序使用了大量的对象. 完全由于使用大量的对象,造成很大的存储开销. 对象的大多数状态都可变为外部状态. 如果删除对象的外部状态, ...

  9. 设计模式之享元模式&lpar;FlyWeight&rpar;

    #include <iostream> #include <string> #include <list> #include <vector> usin ...

随机推荐

  1. Python爬虫入门

    Python爬虫简介(来源于*): 网络爬虫始于一张被称作种子的统一资源地址(URLs)列表.当网络爬虫访问这些统一资源定位器时,它们会甄别出页面上所有的超链接,并将它们写入一张"待访列表",即 ...

  2. sudo gem install cocoapods

    在使用IOS_BaiduSDK的时候,需要用到cocoapods,所以就需要按照步骤继续着.但是在过程中会遇到一些问题: 1. sudo gem install cocoapods 运行这个报错 Ru ...

  3. spring3&period;0注解定时任务配置及说明

    spring注解方式的定时任务配置: 第一步:spring配置文件 <?xml version="1.0" encoding="UTF-8"?> & ...

  4. Shell常见用法小记

    shell的简单使用 最近发现shell脚本在平常工作中简直算一把瑞士军刀,很多场景下用shell脚本能实现常用的简单需求,而之前都没怎么学习过shell,就趁机把shell相关的语法和常见用法总结了 ...

  5. Jenkins2 插件 Pipeline&plus;BlueOcean 实现持续交付的初次演练

    需要完成的目标 使用Pipeline完成项目的checkout,package.deploy.restart 提取出公有部分封装为公有JOB 实现pipeline对其他JOB的调用和逻辑的判断 实现任 ...

  6. leetcode 26 80 删除已排序数组中重复的数据

    80. Remove Duplicates from Sorted Array II Follow up for "Remove Duplicates":What if dupli ...

  7. luogu2597-&lbrack;ZJOI2012&rsqb;灾难 &amp&semi;&amp&semi; DAG支配树

    Description P2597 [ZJOI2012]灾难 - 洛谷 | 计算机科学教育新生态 Solution 根据题意建图, 新建一个 \(S\) 点, 连向每个没有入边的点. 定义每个点 \( ...

  8. react Hooks

    useEffect 1.useEffect是didMount和didUpdate和willUnmount三个函数的集合 2.useEffec(fun):fun会在每次组件render之后执行,而fun ...

  9. 公式编辑器MathType基本使用方法总结----应付本科毕业论文完全没问题啦&Hat;&lowbar;&Hat;

    本人计算数学专业毕业,写毕业论文和外文翻译的时候会遇到大量公式需要编辑,而且学校一般都要求用word.但是Word自带的公式编辑器只支持一种字体,当公式中涉及到特殊字体就不太方便了.如果用Latex来 ...

  10. javascript - 内存空间

    也许很多人像我一样,觉得JS有垃圾回收机制,内存就可以不管了,以至于在全局作用域下定义了很多变量,自以为JS会自动回收,直到最近,看了阮一峰老师,关于javascript内存泄漏的文章时,才发现自己写 ...