享元(FlyWeight)模式

面向对象的代价
面向对象很好地解决了系统抽象性的问题，同时在大多数情况下，也不会损及系统的性能。但是，在某些特殊的应用中下，由于对象的数量太大，采用面向对象会给
系统带来难以承受的内存开销。比如图形应用中的图元等对象、字处理应用中的字符对象等。

1、动机
采用纯粹对象的问题在于大量细粒度的对象会很快充斥在系统中，从而带来很高的运行时代价——主要指内存需求方面的代价。

如何在避免大量细粒度对象问题的同时，让外部客户程序仍然能够透明地使用面向对象的方式来进行操作？

2、意图
运用共享技术有效地支持大量细粒度的对象。

3、图

4、代码

class Font:Object  //12+8(虚表指针，同步)=20 Bytes * n
{
 string fontName; //4 Bytes
 int size;  //4 Bytes
 Color color;  //4 Bytes

 //重写font.equals
}

class Charactor  //2+4(指针)+20+2(填充) + 8=36 Bytes * n
{
 char c;  //2 Bytes
 font f;  //20 Bytes
}

//修改
class Charactor
{
 private static HashTable fontTable;
 char chr;
 Font f;
 Font CFont
 {
  get
  {
   return f;
  }
  set
  
   if(fontTable.Keys.Exist(value))
   {
    this.f = fontTable.Keys[ value ];
   }
   else
   {
    fontTable.Keys.Add(value);
    this.f = value;
   }
  }
 }
 

}

class System
{
 public static void Main()
 {
  //100000：36 * 100000 = 3600000 = 3600K = 3M //还可以
  //10000000：300M 要考虑享元
  ArrayList list = new ArrayList(100000);

  Font f1 = new Font("宋体",5,Color.Red);
  Font f2 = new Font("宋体",5,Color.Red);

  Charactor c = //...
  c.chr = 'A';
  c.CFont = f1;

  Charactor c2 = //...
  c2.chr = 'A';
  c2.CFont = f2;

 }
}

------------------------------------------------------------------------------------------------------

 public abstract class FlyWeight
{
 public void Operation(String state);  //外蕴状态
}

public class ConcreteFlyWeight : FlyWeight
{
 private Character intrinsicState = null; //内蕴状态
 public ConcreteFlyWeight(Character state)
 {
  this.intrinsicState = state;
 }

 public void Opeation(String state)
 {
  ...
 }
}

public class FlyWeightFactory
{
 private HashTable fontTable=new HashTable();
 public FlyWeight factory(Character state)
 {
  if(fontTable.Keys.Exist(state))
  {
   return (FlyWeight)fontTable.Keys[ state ];
  }
  else
  {
   FlyWeight fly = new ConcreteFlyWeight( state );
   fontTable.Keys.Add( fly );
   return fly;
  }
 }
}

public class Client
{
 FlyWeightFactory factory = new FlyWeightFactory();
 FlyWeight fly = factory.factory(new Character('a'));
 fly.Opeation( "First call");
 fly = factory.factory(new Character('b'));
 fly.Opeation( "Second call");
 fly = factory.factory(new Character('a'));
 fly.Opeation( "Third call");
}

5、要点

(1) 面向对象很好地解决了抽象性的问题，但是作为一个运行在机器中的程序实体，我们需要考虑对象的代价问题。FlyWeight设计模式主要解决面向对象的代价问题，一般不触及面向对象的抽象性问题。
(2) FlyWeight采用对象共享的做法来降低系统中对象的个数，从而降低细粒度对象给系统带来的内存压力。在具体实现方面，要注意对象状态的处理。
(3) 对象的数量太大从而导致对象内存开销加大——什么样的数量才算大？这需要我们仔细的根据具体应用情况进行评估，而不能凭空臆断。