1,UML图
单纯享元模式:
抽象享元角色:此角色是所有的具体享元类的超类,为这些规定出需要实现的公共接口。那些需要外蕴状态(External State)的操作可以通过调用商业方法以参数形式传入。
具体享元(ConcreteFlyweight)角色:实现抽象享元角色所规定的接口。如果有内蕴状态的话,必须负责为内蕴状态的话,必须负责为内蕴状态提供存储空间。享元对象的内蕴状态必须与对象所处的周围环境无关,从而使得享元对象可以在系统内共享的。
享元工厂(FlyweightFactory)角色:本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候,享元工厂角色 会检查系统中是否已经有一个复合要要求的享元对象。如果已经有了,享元工厂角色就应当提供这个已有的享元对象;如果系统中没有一个适当的享元对象的话,享元工厂角色就应当创建一个合适的享元对象。
客户端(Client)角色:本角色需要维护一个对所有享元对象的作用。本角色需要自行存储所有享元对象的外蕴状态。
复合享元模式:
抽象享元角色:此角色是所有的具体享元类的超类,为这些类规定出需要实现的公共接口。那 些需要外蕴状态(External State)的操作可以通过方法的参数传入。抽象享元 的接口使得享元变得可能,但是并不强制子类实行共享,因此并非所有的享元对象都是可以共享的。
具体享元(ConreteFlyweight)角色:实现抽象享元角色所规定的接口。如果有内蕴状态的话,必须负责为内蕴状态提供存储空间。享元对象的内蕴状态必须与对象所处的周围环境无关,从而使得享元对象可以在系统内共享。有时候具体享元角色又叫做单纯具体享角色,因为复合享元角色是由单纯具体享元角色通过复合而成。
复合享元(UnsharableFlyweight)角色:复合享元角色所代表的对象是不可以共享的,但是一个复合享元对象可以分解成为多个本身是单纯享对象的组合。复合享元角色又称做不可共享的享元对象。
享元工厂(FlyweightFactory)角色:本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象请求一个享元对象的时候,享元工厂角色需要检查系统中是否已经有一个符合要求的享元对象,如果已经有了,享元工厂角色就应当提供这个已有的享元对象;如果系统中没有一个适当的享元对象的话,享元工厂角色就应当创建一个新的合适的享元对象。
客户端(Client)角色:本角色还需要自行存储所有享元外蕴状态。
2, 模式说明
享元模式以共享的方式高效地支持大量的细粒度对象。享元对象能做到共享的关键是区分内蕴状态(InternalState)和外蕴状态(External State)。
一个内蕴状态是存储在享元对象内部的,并且是不会随环境改变而有所不同的。国此一个享元可以具有内蕴状态并可以共享。
一个外蕴状态是随环境改变而改变的、不可以共享的状态。享元对象的外蕴状态必须由客户端保存,并在享元对象被创建后,在需要使用的时候再传入到享元对象内部。
外蕴状态不可以影响享元对象的内蕴状态。换句话说,它们是相互独立的。
3,模式示例代码[size=large][/size]
单纯享元模式:
package com.maohao.struct.flyweight;
public abstract class Flyweight {
//参数state是外蕴状态
abstract public void operation(String state);
}
package com.maohao.struct.flyweight;
public class ConcreteFlyweight extends Flyweight {
private Character intrinsicState = null;
/**
* 构造子,内蕴状态作为参量传入
*/
public ConcreteFlyweight(Character state) {
this.intrinsicState = state;
}
/**
* 外蕴状态作为参量传入方法中,改变方法的行为
* 但是并不发育对象的内蕴状态
*/
@Override
public void operation(String state) {
System.out.println("...");
}
}
package com.maohao.struct.flyweight;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class FlyweightFactory {
private HashMap flies = new HashMap();
private Flyweight lnkFlyweight;
/**
* 默认构造子
*/
public FlyweightFactory(){}
/**
* 构造子,内蕴状态作为参量传入
*/
public Flyweight factory(Character state) {
if(flies.containsKey(state)) {
return (Flyweight)flies.get(state);
} else {
Flyweight fly = new ConcreteFlyweight(state);
flies.put(state, fly);
return fly;
}
}
/**
* 辅助方法
*/
public void checkFlyweight() {
Flyweight fly;
int i = 0;
for(Iterator it = flies.entrySet().iterator(); it.hasNext() ;) {
Map.Entry e = (Map.Entry)it.next();
System.out.println("Item" + (++i) + ":" + e.getKey());
}
}
}
复合享元模式:
package com.maohao.struct.flyweight;
public abstract class Flyweight2 {
//参数state是外蕴状态
abstract public void operation(String state);
}
package com.maohao.struct.flyweight;
public class ConcreteFlyweight2 extends Flyweight2 {
private Character intrinsicState = null;
/**
* 构造子,内蕴状态作为参量传入
*/
public ConcreteFlyweight2(Character state) {
this.intrinsicState = state;
}
/**
* 外蕴状态作为参量传入方法中,改变方法的行为
* 但是并不发育对象的内蕴状态
*/
@Override
public void operation(String state) {
System.out.println("...");
}
}
package com.maohao.struct.flyweight;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class ConcreteCompositeFlyweight extends Flyweight2 {
private HashMap flies = new HashMap(10);
private Flyweight2 flyweight;
/**
* 默认构造子
*/
public ConcreteCompositeFlyweight() {}
/**
* 增加一个新的单纯享元对象到聚集中
*/
public void add(Character key, Flyweight2 fly) {
flies.put(key, fly);
}
/**
* 外蕴状态作为参量传入到方法中
*/
@Override
public void operation(String state) {
Flyweight2 fly = null;
for(Iterator it = flies.entrySet().iterator(); it.hasNext(); ) {
Map.Entry e = (Map.Entry)it.next();
fly = (Flyweight2)e.getValue();
fly.operation(state);
}
}
}
package com.maohao.struct.flyweight;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class FlyweightFactory2 {
private HashMap flies = new HashMap();
/**
* 默认构造子
*/
public FlyweightFactory2(){}
public Flyweight2 factory(String compositeState) {
ConcreteCompositeFlyweight compositeFly = new ConcreteCompositeFlyweight();
int length = compositeState.length();
Character state = null;
for(int i = 0 ; i < length ; i++) {
state = new Character(compositeState.charAt(i));
System.out.println("factory(" + state + ")");
compositeFly.add(state, this.factory(state));
}
return compositeFly;
}
/**
* 构造子,内蕴状态作为参量传入
*/
public Flyweight2 factory(Character state) {
if(flies.containsKey(state)) {
return (Flyweight2)flies.get(state);
} else {
Flyweight2 fly = new ConcreteFlyweight2(state);
flies.put(state, fly);
return fly;
}
}
/**
* 辅助方法
*/
public void checkFlyweight() {
Flyweight fly;
int i = 0;
for(Iterator it = flies.entrySet().iterator(); it.hasNext() ;) {
Map.Entry e = (Map.Entry)it.next();
System.out.println("Item" + (++i) + ":" + e.getKey());
}
}
}
4。模式优缺点
优点:大幅度地降低内存中对象的数量。
缺点:享元模式使得系统更加复杂。为了使对象可以共享,需要将一些状态外部化,这使得程序的逻辑复杂化。享元模式将享元对象的状态外部化,而读取外部状态使得运行时间稍微变长。
5。模式何时使用
(1)一个系统有大量的对象
(2)这些对象耗费大量的内存
(3)这些对象的状态中的大部分都可以外部化
(4)这些对象可以按照内蕴状态分成很多的组,当把外蕴对象从对象中剔除时,每一个组都可以仅用一个对象代替
(5)软件系统不依赖于这些对象的身份,换言之,这些对象可以是不可分辨的。
使用享元模式需要维护一个记录了系统已有的所有享元的表,而这需要耗费资源。因此,应当在有足够多的享元实例可供共享时才值得使用享元模式。
6,与其他模式比较
与单例模式:享元模式中的享元对象常常与单例模式中的单例对象混淆。享元模式中的单纯享元对象相对于每一个内蕴状态而言是惟一的,但是它们不是单例对象。一个单例类是不能直接实例化的,而单纯享元对象是可以直接实例化的。
与工厂方法模式:享元工厂角色是一个特殊的工厂方法模式,特殊之处在于这个工厂维护一个所创建过的产品对象的记录,并根据这个记录和产品对象的内部状态循环使用这些产品对象。
与代理模式:在代理模式里面,为了避免加载大量的耗费资源的对象,可以使用一些轻量级的代理对象,只在系统真正使用到原始对象时才真正加载它们。享元模式不是这样。在一个使用享元模式的系统里可能看上去有很多的享元对象,好像都是独立的拷贝,但是它其实是被多个客户端共享的单一实例。
与合成模式:严格地讲,享元模式并不是一个单纯的模式,而是一个由数个模式组合而成的复合模式。如前所述,享元模式的工厂角色是一个工厂方法模式,只是工厂的内部记录了所创建的产品实例,并选择使用这些实例。享元对象是合成模式的应用,抽象 享元角色就是复合构件角色,而具体享元角色就是具体构件角色。复合享元是树枝构件,而单纯享元是树叶构件。
7,模式应用
String类使用了享元模式。String对象是不变对象,一旦创建出来就不能改变。如果需要改变一个字符串的值,就只好创建一个新的String对象。在JVM内部,String对象都是共享的。如果一个系统中有两个String对象所包含的字符串相同的话,JVM实际上只创建一个String对象提供给两个引用,从而实现String对象的共享。STring的intern()方法给出这个字符串在共享池中的惟一实例。
- 大小: 34.2 KB
- 大小: 52.1 KB
分享到:
相关推荐
享元模式是软件设计模式中的一种结构型模式,它的主要目的是为了提高性能,尤其是在处理大量对象时。在享元模式中,通过共享技术来有效支持大量细粒度的对象,从而减少内存消耗。《设计模式之禅》这本书是设计模式...
享元模式是软件设计模式中的一种结构型模式,它的主要目的是通过共享大量细粒度对象来减少内存的使用,提高系统性能。在许多场景下,尤其是处理大量相似对象时,享元模式能显著减少内存开销。这个压缩包文件...
享元模式是软件设计模式中的一种结构型模式,它的核心思想是通过共享已经存在的对象来减少内存中的对象数量,从而提高系统性能。在Java中,享元模式常用于处理大量相似对象的场景,例如在图形界面中绘制大量相似的...
在本文中,我们将深入探讨结构型设计模式,特别是桥接模式、适配器模式、装饰者模式和组合模式,以及它们在实际场景中的应用。 1. **桥接模式**: 桥接模式将抽象部分与实现部分分离,使得它们可以独立进行变化。...
JAVA-设计模式-结构型模式-享元模式
今天我们要探讨的是“Java设计模式之结构型模式”。结构型模式主要关注如何组织类和对象,以达到良好的架构,提升代码的可读性和可维护性。在这个主题中,我们将深入理解并讨论这些模式的原理、应用场景及其实现。 ...
在这个“C#面向对象设计模式纵横谈(12)”中,我们将深入探讨享元模式的概念、实现方式以及如何在实际项目中应用。 享元模式的核心思想是区分对象的状态和行为。状态分为内部状态和外部状态,其中内部状态是对象共有...
享元模式是设计模式中的一种结构型模式,它主要通过共享已有对象来减少内存中对象的数量,从而提高系统性能。在C#编程中,享元模式尤其适用于那些创建大量相似对象且内存消耗较大的场景。本篇文章将深入探讨享元模式...
在IT行业中,软件体系结构设计模式是开发高质量、可维护和可扩展的软件系统的关键要素。设计模式是一种在特定上下文中解决常见问题的最佳实践,它为软件设计提供了可重用的解决方案。本作业将深入探讨软件体系结构...
2. 结构型模式:如适配器模式、装饰器模式、代理模式、桥接模式、组合模式、外观模式和享元模式。这些模式关注的是如何将类或对象结合在一起形成更大的结构,同时保持它们之间的松耦合。 3. 行为型模式:如策略模式...
这是JAVA设计模式中属于结构模式的部分,包括Flyweight(共享模式)、Bridge(桥模式)、Decorator(装饰模式)、Composite(组合模式)、Adapter(适配器模式)、Proxy(代理模式)、Facade (外观模式)的源代码。其中有些模式中...
享元模式是一种结构型设计模式,它通过共享已有对象来减少内存中对象的数量,从而达到降低系统内存占用、提高性能的目的。在软件工程中,当系统中存在大量相似或重复的对象时,享元模式尤为适用。 享元模式的核心是...
设计模式通常被划分为三个主要类别:创建型模式、结构型模式和行为型模式。 《设计模式之蝉》这本书可能是对设计模式的一种形象化描述,或是以蝉为比喻来讲解设计模式的概念。蝉在地下蛰伏多年,最终破土而出,仅...
在软件开发领域,设计模式和体系结构是至关重要的概念,它们是解决常见问题的模板,为软件的可扩展性、可维护性和可重用性提供了基础。本资源"软件设计模式与体系结构课后习题代码(孙玉山).zip"包含了孙玉山教授讲解...
享元模式(Flyweight)是23种设计模式之一,属于结构型设计模式。该模式通过共享技术,有效地支持大量细粒度对象的复用。享元模式的目的是为了减少创建对象的数量,以减少内存占用和提高性能。 ### 细粒度对象 享元...
第一篇分为8章,介绍了软件体系结构的基础理论,包括软件体系结构的概念及演化、软件建模基础、软件体系结构的形式化、软件体系结构的风格、体系结构的描述语言、软件质量建模、设计模式等内容。第二篇分为4章,首先...
《软件设计模式与体系结构》是软件开发领域中的核心理论之一,它关乎到软件的可维护性、可扩展性和灵活性。这份压缩包“软件设计模式与体系结构(期末复习1).rar”包含了对这一主题的复习资料,特别是对于期末考试...
孙云山老师的“软件设计模式与体系结构”课程深入探讨了这些模式及其在构建复杂系统中的应用。本资料集合包含了课后习题的第234章答案,这将有助于学生深化对设计模式的理解,并提升其实际应用能力。 设计模式是...