`
javabkb
  • 浏览: 54493 次
  • 性别: Icon_minigender_1
  • 来自: 天津
社区版块
存档分类
最新评论

设计模式之结构模式之享元模式

 
阅读更多
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设计模式之享元模式

    享元模式是软件设计模式中的一种结构型模式,它的核心思想是通过共享已经存在的对象来减少内存中的对象数量,从而提高系统性能。在Java中,享元模式常用于处理大量相似对象的场景,例如在图形界面中绘制大量相似的...

    设计模式之结构型模式

    在本文中,我们将深入探讨结构型设计模式,特别是桥接模式、适配器模式、装饰者模式和组合模式,以及它们在实际场景中的应用。 1. **桥接模式**: 桥接模式将抽象部分与实现部分分离,使得它们可以独立进行变化。...

    JAVA-设计模式-结构型模式-享元模式

    JAVA-设计模式-结构型模式-享元模式

    Java设计模式之结构型模式源码以及文档

    今天我们要探讨的是“Java设计模式之结构型模式”。结构型模式主要关注如何组织类和对象,以达到良好的架构,提升代码的可读性和可维护性。在这个主题中,我们将深入理解并讨论这些模式的原理、应用场景及其实现。 ...

    C#面向对象设计模式纵横谈(12):Flyweight 享元模式(结构型模式) (Level 300)

    在这个“C#面向对象设计模式纵横谈(12)”中,我们将深入探讨享元模式的概念、实现方式以及如何在实际项目中应用。 享元模式的核心思想是区分对象的状态和行为。状态分为内部状态和外部状态,其中内部状态是对象共有...

    设计模式(C#)之享元模式(Flyweight Pattern)

    享元模式是设计模式中的一种结构型模式,它主要通过共享已有对象来减少内存中对象的数量,从而提高系统性能。在C#编程中,享元模式尤其适用于那些创建大量相似对象且内存消耗较大的场景。本篇文章将深入探讨享元模式...

    软件体系结构设计模式作业

    在IT行业中,软件体系结构设计模式是开发高质量、可维护和可扩展的软件系统的关键要素。设计模式是一种在特定上下文中解决常见问题的最佳实践,它为软件设计提供了可重用的解决方案。本作业将深入探讨软件体系结构...

    设计模式之美——教你写出高质量代码

    2. 结构型模式:如适配器模式、装饰器模式、代理模式、桥接模式、组合模式、外观模式和享元模式。这些模式关注的是如何将类或对象结合在一起形成更大的结构,同时保持它们之间的松耦合。 3. 行为型模式:如策略模式...

    JAVA设计模式之结构模式

    这是JAVA设计模式中属于结构模式的部分,包括Flyweight(共享模式)、Bridge(桥模式)、Decorator(装饰模式)、Composite(组合模式)、Adapter(适配器模式)、Proxy(代理模式)、Facade (外观模式)的源代码。其中有些模式中...

    设计模式-享元模式(讲解及其实现代码)

    享元模式是一种结构型设计模式,它通过共享已有对象来减少内存中对象的数量,从而达到降低系统内存占用、提高性能的目的。在软件工程中,当系统中存在大量相似或重复的对象时,享元模式尤为适用。 享元模式的核心是...

    设计模式之蝉

    设计模式通常被划分为三个主要类别:创建型模式、结构型模式和行为型模式。 《设计模式之蝉》这本书可能是对设计模式的一种形象化描述,或是以蝉为比喻来讲解设计模式的概念。蝉在地下蛰伏多年,最终破土而出,仅...

    软件设计模式与体系结构课后习题代码(孙玉山).zip

    在软件开发领域,设计模式和体系结构是至关重要的概念,它们是解决常见问题的模板,为软件的可扩展性、可维护性和可重用性提供了基础。本资源"软件设计模式与体系结构课后习题代码(孙玉山).zip"包含了孙玉山教授讲解...

    设计模式_结构型_享元模式.md

    享元模式(Flyweight)是23种设计模式之一,属于结构型设计模式。该模式通过共享技术,有效地支持大量细粒度对象的复用。享元模式的目的是为了减少创建对象的数量,以减少内存占用和提高性能。 ### 细粒度对象 享元...

    软件设计模式与体系结构

    第一篇分为8章,介绍了软件体系结构的基础理论,包括软件体系结构的概念及演化、软件建模基础、软件体系结构的形式化、软件体系结构的风格、体系结构的描述语言、软件质量建模、设计模式等内容。第二篇分为4章,首先...

    软件设计模式与体系结构(期末复习1).rar

    《软件设计模式与体系结构》是软件开发领域中的核心理论之一,它关乎到软件的可维护性、可扩展性和灵活性。这份压缩包“软件设计模式与体系结构(期末复习1).rar”包含了对这一主题的复习资料,特别是对于期末考试...

    软件设计模式与体系结构孙云山课后习题234章答案.zip

    孙云山老师的“软件设计模式与体系结构”课程深入探讨了这些模式及其在构建复杂系统中的应用。本资料集合包含了课后习题的第234章答案,这将有助于学生深化对设计模式的理解,并提升其实际应用能力。 设计模式是...

Global site tag (gtag.js) - Google Analytics