设计模式学习笔记（二十二）—FlyWeight享元模式

设计模式学习笔记（二十二）—FlyWeight享元模式2011-02-27 blogjava 蝸ゼ牜ご赽跑一、FlyWeight模式定义:

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

二、模式解说

也就是说在一个系统中如果有多个相同的对象，那么只共享一份就可以了，不必每个都去实例化一个对象。在Flyweight模式中，由于要产生各种各样的对象，所以在Flyweight（享元）模式中常出现Factory模式。Flyweight的内部状态是用来共享的,Flyweight factory负责维护一个对象存储池（Flyweight Pool）来存放内部状态的对象。Flyweight模式是一个提高程序效率和性能的模式,会大大加快程序的运行速度。

三、结构图

享元模式所涉及的角色有抽象享元角色、具体（单纯）享元角色、复合享元角色、享员工厂角色，以及客户端角色等。

抽象享元角色（Flyweight）：此角色是所有的具体享元类的超类，为这些类规定出需要实现的公共接口或抽象类。那些需要外蕴状态（External State）的操作可以通过方法的参数传入。抽象享元的接口使得享元变得可能，但是并不强制子类实行共享，因此并非所有的享元对象都是可以共享的。

具体享元（ConcreteFlyweight）角色：实现抽象享元角色所规定的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。享元对象的内蕴状态必须与对象所处的周围环境无关，从而使得享元对象可以在系统内共享。有时候具体享元角色又叫做单纯具体享元角色，因为复合享元角色是由单纯具体享元角色通过复合而成的。

复合享元（UnsharableFlyweight）角色：复合享元角色所代表的对象是不可以共享的，但是一个复合享元对象可以分解成为多个本身是单纯享元对象的组合。复合享元角色又称做不可共享的享元对象。这个角色一般很少使用。

享元工厂（FlyweightFactoiy）角色：本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象请求一个享元对象的时候，享元工厂角色需要检查系统中是否已经有一个符合要求的享元对象，如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个新的合适的享元对象。

客户端（Client）角色：本角色还需要自行存储所有享元对象的外蕴状态。

四、一个例子

import java.util.Hashtable;

/**
*
* @author <a href="mailto:flustar2008@163.com">flustar</a>
* @version 1.0
* Creation date: Jan 25, 2008 1:33:49 PM
*/

  // "Flyweight"

  abstract class Character
  {
   protected char symbol;
   protected int width;
   protected int height;
   protected int ascent;
   protected int descent;
   protected int pointSize;

   public abstract void Display（int pointSize）;
  }

  // "ConcreteFlyweight"

  class CharacterA extends Character
  {
   // Constructor
   public CharacterA（）
   {
    this.symbol = "A";
    this.height = 100;
    this.width = 120;
    this.ascent = 70;
    this.descent = 0;
   }

   public void Display（int pointSize）
   {
    this.pointSize = pointSize;
   System.out.println（this.symbol +
     " （pointsize " + this.pointSize + "）"）;
   }
  }

  // "ConcreteFlyweight"

  class CharacterB extends Character
  {
   // Constructor
   public CharacterB（）
   {
    this.symbol = "B";
    this.height = 100;
    this.width = 140;
    this.ascent = 72;
    this.descent = 0;
   }

   public void Display（int pointSize）
   {
    this.pointSize = pointSize;
   System.out.println（this.symbol +
     " （pointsize " + this.pointSize + "）"）;
   }

  }

  // C, D, E, etc.

  // "ConcreteFlyweight"

  class CharacterZ extends Character
  {
   // Constructor
   public CharacterZ（）
   {
    this.symbol = "Z";
    this.height = 100;
    this.width = 100;
    this.ascent = 68;
    this.descent = 0;
   }

   public void Display（int pointSize）
   {
    this.pointSize = pointSize;
    System.out.println（this.symbol +
     " （pointsize " + this.pointSize + "）"）;
   }
  }
  // "FlyweightFactory"

  class CharacterFactory
  {
   private Hashtable characters = new Hashtable（）;

   public Character GetCharacter（char key）
   {
    // Uses "lazy initialization"
    Character character = （Character）characters.get（key）;
    if （character == null）
    {
     switch （key）
     {
      case "A": character = new CharacterA（）; break;
      case "B": character = new CharacterB（）; break;
       //
      case "Z": character = new CharacterZ（）; break;
     }
     characters.put（key, character）;
    }
    return character;
   }
  }
// test application
  public class Test
  {
   public static void main（String []args）
   {
    // Build a document with text
    String document = "AAZZBBZB";
    char[] chars = document.toCharArray（）;

    CharacterFactory f = new CharacterFactory（）;

    // extrinsic state
    int pointSize = 10;

    // For each character use a flyweight object
    for（char c : chars）
    {
     pointSize++;
     Character character = f.GetCharacter（c）;
     character.Display（pointSize）;
    }

   }
  }