设计模式之享元模式

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

public abstract class Flyweight{  
    public abstract void operation();  
}  

再定义一个具体的实现类

public class ConcreteFlyweight extends Flyweight{  
    private String string;  
    public ConcreteFlyweight(String str){  
         string = str;  
    }  
    public void operation()  
   {  
       System.out.println("Concrete---Flyweight : " + string);  
   }  
}  

再实现一个工厂类

import java.util.Hashtable;  
   public class FlyweightFactory{  
     private Hashtable flyweights = new Hashtable();
     public FlyweightFactory(){}  
     public Flyweight getFlyWeight(Object obj){  
        Flyweight flyweight = (Flyweight) flyweights.get(obj);
        if(flyweight == null){
            flyweight = new ConcreteFlyweight((String)obj);  
            flyweights.put(obj, flyweight);
        }
        return flyweight;
     } 
      public int getFlyweightSize(){  
        return flyweights.size();  
    }  
}  

客户端测试类

  public class Client{  
    FlyweightFactory factory = new FlyweightFactory();   
    Flyweight fly1;  
    Flyweight fly2;  
    Flyweight fly3;  
    Flyweight fly4;  
    Flyweight fly5;  
    Flyweight fly6;  

   public Client(){  
       fly1 = factory.getFlyWeight("Google");  
       fly2 = factory.getFlyWeight("Qutr");  
       fly3 = factory.getFlyWeight("Google");  
       fly4 = factory.getFlyWeight("Google");  
       fly5 = factory.getFlyWeight("Google");  
       fly6 = factory.getFlyWeight("Google");  
     }  
   public void showFlyweight(){  
       fly1.operation();  
       fly2.operation();  
       fly3.operation();  
       fly4.operation();  
       fly5.operation();  
       fly6.operation();  
       int objSize = factory.getFlyweightSize();  
       System.out.println("objSize = " + objSize);  
   }  
   public static void main(String[] args){  
       System.out.println("The FlyWeight Pattern!");  
       Client fp = new Client();  
       fp.showFlyweight();  
   }  
}  

在这里定义了6个对象，但是在实际上只有两个实例化的对象，这样就可以节省大量的内存空间。

核心总结，可以共享的对象，也就是说返回的同一类型的对象其实是同一实例，当客户端要求生成一个对象时，工厂会检测是否存在此对象的实例，如果存在那么直接返回此对象实例，如果不存在就创建一个并保存起来