【进阶之路】理解结构型模式开发（享元模式）

 	 Integer integer1=new Integer(1);
         Integer integer2=new Integer(2);
         System.out.println(integer1==integer2);	 //false

   	 Integer integer3=2;	//放入Integer常量池
   	 Integer integer4=2; //从量池获取
   	 System.out.println(integer3==integer4);	 //true

        Integer integer5=128;
        Integer integer6=128;
        System.out.println(integer5==integer6);	 //false

相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。

为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。
读取享元模式的外部状态会使得运行时间稍微变长。

抽象享元角色（Flyweight）:是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。
非享元（Unsharable Flyweight)角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

public interface Flyweight {
    public void operate(String type);
}

public class CharacterFlyweight implements Flyweight{
    //内部状态即是不变的，外部状态是变化的,然后通过共享不变的部分，达到减少对象数量并节约内存的目的
    private String name;

    /**
     * 外部状态（非享元）
     * @param name
     */
    public CharacterFlyweight(String name) {
        this.name = name;
    }

    /**
     * 具体享元+非享元结合
     * @param type
     */
    @Override
    public void operate(String type) {
        System.out.println("姓名 = " + name);
        System.out.println("属性 = " + type);
    }
}

public class FlyweightFactory {
    //由工厂方法产生所需要的享元对象。
    private Map characterPool = new HashMap();

    public Flyweight factory(String user){
        //先从缓存中查找对象
        Flyweight flyweight = characterPool.get(user);
        if(flyweight == null){
            //如果对象不存在则创建一个新的对象
            flyweight = new CharacterFlyweight(user);
            //新对象添加到缓存中
            characterPool.put(user, flyweight);
        }
        return flyweight;
    }
}

 public static void main(String[] args) {

        FlyweightFactory factory = new FlyweightFactory();
        Flyweight flyweight1 = factory.factory("蛇夫");
        flyweight1.operate("蛇夫赶小犬");

        Flyweight flyweight2 = factory.factory("室女");
        flyweight2.operate("梦游室女座");

        Flyweight flyweight3 = factory.factory("蛇夫");
        flyweight3.operate("蛇夫逐天狼");

        System.out.println(flyweight1==flyweight3);//true
    }
    

public interface Flyweight {
    public void operate(String type);
}

public class CharacterFlyweight implements Flyweight{
    //内部状态即是不变的，外部状态是变化的,然后通过共享不变的部分，达到减少对象数量并节约内存的目的
    private String name;

    /**
     * 外部状态（非享元）
     * @param name
     */
    public CharacterFlyweight(String name) {
        this.name = name;
    }

    /**
     * 具体享元+非享元结合
     * @param type
     */
    @Override
    public void operate(String type) {
        System.out.println("姓名 = " + name);
        System.out.println("属性 = " + type);
    }
}

public class CharacterCompositeFlyweight implements Flyweight{
    private Map files = new HashMap();
    /**
     * 增加一个新的单纯享元对象到即合理
     */
    public void add(String key , Flyweight fly){
        files.put(key,fly);
    }
    /**
     * 外部状态作为参数传入到方法中
     */

    @Override
    public void operate(String type) {
        Flyweight fly ;
        for(Object o : files.keySet()){
            fly = files.get(o);
            fly.operate(type);
        }
    }
}

public class FlyweightFactory {

    private Map characterPool = new HashMap();
    /**
     * 复合享元工厂方法
     * 一种用于提供单纯享元对象，另一种用于提供复合享元对象
     */
    public Flyweight factory(List compositeState){
        CharacterCompositeFlyweight compositeFlyweight = new CharacterCompositeFlyweight();

        for(String state : compositeState){
            compositeFlyweight.add(state,this.factory(state));
        }

        return compositeFlyweight;
    }

    /**
     *单纯工厂方法产生所需要的享元对象。
     */
    public Flyweight factory(String user){
        //先从缓存中查找对象
        Flyweight flyweight = characterPool.get(user);
        if(flyweight == null){
            //如果对象不存在则创建一个新的对象
            flyweight = new CharacterFlyweight(user);
            //新对象添加到缓存中
            characterPool.put(user, flyweight);
        }
        return flyweight;
    }
}

 
    public static void main(String[] args) {

        List compositeState = new ArrayList();
        compositeState.add("室女");
        compositeState.add("双子");
        compositeState.add("武仙");
        compositeState.add("双子");
        compositeState.add("室女");

        FlyweightFactory flyFactory = new FlyweightFactory();
        Flyweight compositeFly1 = flyFactory.factory(compositeState);
        Flyweight compositeFly2 = flyFactory.factory(compositeState);
        compositeFly1.operate("梦游中...");

        System.out.println("---------------------------------");
        System.out.println("复合享元模式是否可以共享对象：" + (compositeFly1 == compositeFly2)); //false

        String user = "室女";
        Flyweight fly1 = flyFactory.factory(user);
        Flyweight fly2 = flyFactory.factory(user);
        System.out.println("单纯享元模式是否可以共享对象：" + (fly1 == fly2)); //true
    }