7享元模式

• 内部状态是存储在享元对象内部的、可以共享的信息，并且不会随环境改变而改变。
• 外部状态是随环境改变而改变且不可以共享的状态。享元对象的外部状态必须有客户端保存，并且在享元对象被创建之后，在需要使用的时候再传入到享元对象的内部。

• 抽象享元(Flyweight )角色：该角色对享元类进行抽象，需要外部状态的操作可以通过参数的形式将外部状态传入。
• 具体享元(Concrete Flyweight)角色：该角色实现抽象享元定义的业务，注意享元对象可以在系统内共享。
• 享元工厂(FlyweightFactory)角色：构造一个池容器，并负责创建和管理享元角色，提供从池容器中获得对象的方法，保证享元对象可以被系统适当的共享。当一个客户端对象请求一个享元对象时，享元工厂角色会去检查系统中是否已经有一个符合要求的享元对象。如果已经有了，享元工厂则提供这个已有的享元对象；否则创建一个合适的享元对象。
• 客户端(Client)角色：该角色需要自行存储所有享元对象的外部状态。

package com.eric.结构型模式.享元模式.引例;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 抽象享元角色
 * @CreateTime 2020-12-03 11:27:05
 */
public interface Flyweight {
    //业务方法
    public abstract void operation(String  extrinsicState);
}

package com.eric.结构型模式.享元模式.引例;


/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 具体享元
 * @CreateTime 2020-12-03 11:29:24
 */
public class ConcreteFlyweight implements Flyweight{
    private String intrinsicState; //内部状态
    ConcreteFlyweight(String intrinsicState){
        this.intrinsicState = intrinsicState;
    }

    @Override
    public void operation(String extrinsicState) {
        System.out.println("内部状态"+intrinsicState+"---外部状态"+extrinsicState);
    }
}

package com.eric.结构型模式.享元模式.引例;

import java.util.HashMap;
import java.util.Map;
/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 享元工厂
 * @CreateTime 2020-12-03 11:33:03
 */
public class FlyweightFactory {
    private static Map<String,Flyweight> pool = new HashMap<String, Flyweight>();
    private FlyweightFactory(){}//私有构造方法
    public static Flyweight getFlyweight(String intrinsicState){
        Flyweight flyweight = pool.get(intrinsicState);
        if(flyweight == null){
            flyweight = new ConcreteFlyweight(intrinsicState);
            pool.put(intrinsicState,flyweight);
        }
        return flyweight;
    }
}

• 享元模式增加了系统的复杂性，需要分出外部状态和内部状态，而且内部状态具有固化特性，不应该随外部状态改变而改变，这使得程序的逻辑复杂化。
• 享元模式将享元对象的状态外部化，而读取外部状态使得运行时间变长。

• 系统中有大量的相似对象，这些对象耗费大量内存。
• 细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关，几对象没有特定的身份。

package com.eric.结构型模式.享元模式.例1;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 棋子接口规范
 * @CreateTime 2020-12-03 13:17:38
 */
public interface Chesspiece  {
    //落子
    void put(int x,int y);
}

package com.eric.结构型模式.享元模式.例1;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 棋子具体享元
 * @CreateTime 2020-12-03 13:48:48
 */
public class ChesspieceFlyweight implements Chesspiece {
    private String color;

    public ChesspieceFlyweight(String color){
        this.color = color;
    }

    @Override
    public void put(int x, int y) {
        System.out.println("在("+x+","+y+")位置放了一个"+color+"子");
    }
}

package com.eric.结构型模式.享元模式.例1;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 棋子工厂
 * @CreateTime 2020-12-03 13:55:23
 */
public class ChesspieceFactory {
   private static final Chesspiece WHITE = new ChesspieceFlyweight("白");
   private static final Chesspiece BLACK = new ChesspieceFlyweight("黑");

    public static Chesspiece getChesspiece(String color){
        if("白".equals(color))return WHITE;
        else if("黑".equals(color))return BLACK;
        return null;
    }
}

package com.eric.结构型模式.享元模式.例1;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 开始游戏
 * @CreateTime 2020-12-03 14:00:09
 */
public class Game {
    public static void main(String[] args) {
        Chesspiece chesspiece1 = ChesspieceFactory.getChesspiece("黑");
        chesspiece1.put(3,3);
        Chesspiece chesspiece2 = ChesspieceFactory.getChesspiece("白");
        chesspiece2.put(3,4);
        Chesspiece chesspiece3= ChesspieceFactory.getChesspiece("黑");
        chesspiece3.put(2,4);
        Chesspiece chesspiece4 = ChesspieceFactory.getChesspiece("白");
        chesspiece4.put(4,4);
    }
}