亨元模式

亨元模式和单例模式相似，都是为了节省内存。

对于一个可复用的对象，一百个需要用到的地方获得同一个对象比创建一百个新的对象更节省内存，这就是单例模式。

亨元模式在单例的基础上进行了拓展，把状态分成可共享的内部状态和不可共享的外部状态。能共享内部状态的获取同一个对象。

亨元模式的核心在Factory，它负责判断是创建新对象还是返回已有对象。

代码如下：

写一个亨元抽象类：

public abstract class Flyweight {
    public String inner;
    public Flyweight(String inner)
    {
        this.inner=inner;
    }
    public abstract void operation(String out);
}

写实现：

public class FlyweightImp extends Flyweight{
    public FlyweightImp(String inner) {
        super(inner);
    }
    public void operation(String out) {
        System.out.println("this is inner state:"+inner);
        System.out.println("this is out state:"+out);
    }
}

写工厂：

public class FlyweightFactory {
    public static Map<String,Flyweight> FlyMap=new HashMap<String,Flyweight>();
    public static Flyweight getFly(String inner)
    {
        if(FlyMap.containsKey(inner))
        {
            return FlyMap.get(inner);
        }
        else
        {
            Flyweight f=new FlyweightImp(inner);
            FlyMap.put(inner, f);
            return f;
        }
    }
}

最后测试：

public class test {
    public static void main(String[] args)
    {
        Flyweight fw=FlyweightFactory.getFly("a");
        fw.operation("out1");
        fw=FlyweightFactory.getFly("a");
        fw.operation("out2");
        fw=FlyweightFactory.getFly("b");
        fw.operation("out3");
        fw=FlyweightFactory.getFly("b");
        fw.operation("out4");
    }
}

在测试中，一共创建了两个Flyweight。