享元模式（Flyweight Pattern）

享元模式

说明

享元模式（Flyweight Pattern）属于结构型模式，指运用共享技术有效地支持大量细粒度对象。
享元模式中的对象分为内部状态和外部状态，内部状态是共享不可变的，而外部状态会根据客户端的调用进行改变。

结构

享元模式有三个主要角色：
抽象享元角色（Flyweight）：所有具体享元类的超类或接口，同时定义了作用于外部状态的接口。
具体享元角色（ConcreteFlyweight）：实现Flyweight接口或继承Flyweight超类，并且定义了内部状态；
享元工厂（FlyweightFactory）：创建并且管理享元对象，客户端通过该工厂类获得具体的享元对象。

代码案例

/**
 * @program: flyweight
 * @description: 棋子抽象接口，抽象享元角色（Flyweight）
 * @author: wxw
 * @create: 2022-03-07 21:48
 **/
public interface IChessman {

    /**
     * 显示当前棋子的位置，由客户端操作的外部方法
     * @param order
     * @param x
     * @param y
     */
    void show(int order, int x, int y);
}

/**
 * @program: flyweight
 * @description: 五子棋，具体享元角色（ConcreteFlyweight）
 * @author: wxw
 * @create: 2022-03-07 21:50
 **/
public class Gomoku implements IChessman{
    // 五子棋颜色，内部状态
    private String color;

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

    @Override
    public void show(int order, int x, int y) {
        System.out.println(String.format("第%s颗%s棋子在棋盘的位置：x:%s\ty:%s",
                order,this.color,x,y));
    }
}

/**
 * @program: flyweight
 * @description: 享元工厂类
 * @author: wxw
 * @create: 2022-03-07 21:57
 **/
public class FlyweightFactory {

    private static final FlyweightFactory flyweightFactory = new FlyweightFactory();

    private static HashMap<String, IChessman> chessmanPool = new HashMap<>();

    private FlyweightFactory(){}

    public static FlyweightFactory getInstance(){
        return flyweightFactory;
    }

    /**
     * 获得具体享元角色的方法
     * @param color
     * @return
     */
    public IChessman getGomoku(String color){
        if(!chessmanPool.containsKey(color)){
            chessmanPool.put(color, new Gomoku(color));
        }
        return chessmanPool.get(color);
    }

    public int getGomokuCount(){
        return chessmanPool.size();
    }

}

/**
 * @program: flyweight
 * @description: 棋手类
 * @author: wxw
 * @create: 2022-03-07 22:05
 **/
@Data
public class ChessPlayer {

    private String name;
    private int order;

    public ChessPlayer(String name) {
        this.name = name;
        this.order = 1;
    }

    /**
     * 落子方法
     */
    public void moveInChess(IChessman gomoku){
        Random random = new Random();
        int x = random.nextInt(14) + 1;
        int y = random.nextInt(14) + 1;
        System.out.print(String.format("%s落子：",name));
        gomoku.show(order++,x,y);
    }

}

/**
 * @program: flyweight
 * @description:
 * @author: wxw
 * @create: 2022-03-07 22:16
 **/
public class Test {
    public static void main(String[] args) {
        System.out.println("=================五子棋游戏开始===============");
        ChessPlayer zhangsan = new ChessPlayer("张三");
        ChessPlayer lisi = new ChessPlayer("李四");
        System.out.println(zhangsan.getName() + " VS " + lisi.getName());
        FlyweightFactory flyweightFactory = FlyweightFactory.getInstance();
        for (int i = 0; i < 10; i++){
            // 偶数张三落子，奇数李四落子
            if(i % 2 == 0){
                IChessman gomoku = flyweightFactory.getGomoku("黑色");
                zhangsan.moveInChess(gomoku);
            }else{
                IChessman gomoku = flyweightFactory.getGomoku("白色");
                lisi.moveInChess(gomoku);
            }
        }

        System.out.println("缓存中的棋子对象个数：" + flyweightFactory.getGomokuCount());
    }
}

输出结果：

=================五子棋游戏开始===============
张三 VS 李四
张三落子：第1颗黑色棋子在棋盘的位置：x:7	y:6
李四落子：第1颗白色棋子在棋盘的位置：x:8	y:5
张三落子：第2颗黑色棋子在棋盘的位置：x:8	y:4
李四落子：第2颗白色棋子在棋盘的位置：x:7	y:2
张三落子：第3颗黑色棋子在棋盘的位置：x:12	y:10
李四落子：第3颗白色棋子在棋盘的位置：x:5	y:9
张三落子：第4颗黑色棋子在棋盘的位置：x:14	y:13
李四落子：第4颗白色棋子在棋盘的位置：x:7	y:1
张三落子：第5颗黑色棋子在棋盘的位置：x:14	y:5
李四落子：第5颗白色棋子在棋盘的位置：x:6	y:8
缓存中的棋子对象个数：2