一天学习一个设计模式之享元模式

享元模式（flyweight），运用共享技术有效地支持大量细粒度的对象。

该模式代码如下：

/**
 * 抽象享元角色类
 */
public interface IFlyweight {
    //一个示意性方法，参数state是外蕴状态
    void operation(String state);
}

　　

/**
 * 具体享元角色类ConcreteFlyweigh
 */
public class ConcreteFlyweight implements IFlyweight {
    private Character intrinsicState = null;

    /**
     * 构造函数，内部状态作为参数传入
     * @param state
     */
    public ConcreteFlyweight(Character state) {
        this.intrinsicState = state;
    }

    /**
     * 外部状态作为参数传入方法，改变方法行为
     * 但是并不改变对象的内部状态。
     * @param state
     */
    @Override
    public void operation(String state) {
        System.out.println("Intrinsic state="+this.intrinsicState);
        System.out.println("Extrinsic state="+state);
    }
}

/**
 * 享元工厂角色类
 */
public class FlyweightFactory {
    private Map<Character,IFlyweight> files=new HashMap<>();

    public IFlyweight factory(Character state){
       //先从缓存中查找对象
        IFlyweight fly=files.get(state);
        if (fly==null){
            //如果对象不存在则创建一个新的Flyweight对象
            fly=new ConcreteFlyweight(state);
            //把这个新的Flyweight对象添加到缓存中
            files.put(state,fly);
        }
        return fly;
    }
}

public class Client {
    public static void main(String[] args) {
        FlyweightFactory factory=new FlyweightFactory();
        IFlyweight fly=factory.factory(new Character('a'));
        fly.operation("First Call");
        fly=factory.factory(new Character('b'));
        fly.operation("Second Call");
        fly=factory.factory(new Character('a'));
        fly.operation("Third Call");

    }
}

　　享元模式可以避免大量非常相似的开销。在程序设计中，有时需要生成大量细粒度的类实例来表示数据。如果能发现这些实例除了几个参数外基本上都是相同的，有时就能够受大幅度地减少需要实例化的类的数量。如果能把那些参数移到类实例的外面，在方法调用时将它们传递进来，就可以通过共享大幅度地减少单个实例的数目。

　　如果一个应用程序使用大量的对象，而大量的这些对象造成了很大的存储开销时就应该考虑使用；还有就是对象的大多数状态可以外部状态，如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象，此时可以考虑使用享元模式。