模式之享元模式

定义

允许使用对象共享来有效地支持大量细粒度对象

使用场景

当你的程序中存在大量相似对象，每个对象之间只是根据不同的使用场景有些许变化时。

重要概念

共享对象的状态分为内部状态与外部状态，内部状态在各个对象间共享，而外部状态由客户端传入

实例

五子棋设计：这里需要大量的棋子对象，他们除了颜色有黑白之分，摆放的位置不同其他都一样，棋子对象分为黑白两类，所以将颜色设计为对象的内部状态来共享

/**
 * 享元模式：允许使用对象共享来有效地支持大量细粒度对象
 * 使用场景：
 *  当你的程序中存在大量相似的对象，每个对象之间只是根据不同的使用场景有些许变化时
 * @author
 * @date 2023/02/01 16:49
 **/
// 五子棋设计：这里需要大量的棋子对象，他们除了颜色有黑白之分，摆放的位置不同其他都一样
public interface Chess {
    // 绘制棋子
    void draw(int x, int y);
}
// 棋子对象分为黑白两类，所以将颜色设计为对象的内部状态来共享
class BlackChess implements Chess {
    // 内部状态，共享
    private final Color color = Color.BLACK;
    private final String sharp = "圆形";
    public Color getColor() {
        return color;
    }
    @Override
    public void draw(int x, int y) {
        System.out.println(String.format("%s%s棋子置于(%d,%d)处", sharp, "黑",x,y));
    }
}
class WhiteChess implements Chess {
    private final Color color = Color.WHITE;
    private final String sharp = "圆形";
    public Color getColor() {
        return color;
    }
    @Override
    public void draw(int x, int y) {
        System.out.println(String.format("%s%s棋子置于(%d,%d)处", sharp, "白",x,y));
    }
}
class ChessFactory {
    private static final Map<Color, Chess> chessMap = new HashMap<>();
    public static Chess getChess(Color color){
        Chess chess = chessMap.get(color);
        if(chess == null){
            chess = color == Color.WHITE?new WhiteChess():new BlackChess();
            chessMap.put(color, chess);
        }
        return chess;
    }
}
class FlyweightClient {
    public void playChess() {
        // 下黑子
        Chess backChess1 = ChessFactory.getChess(Color.BLACK);
        backChess1.draw(2,5);
        // 下白子
        Chess whiteChess = ChessFactory.getChess(Color.WHITE);
        whiteChess.draw(3,5);
        // 下黑子
        Chess backChess2 = ChessFactory.getChess(Color.BLACK);
        backChess2.draw(2,6);
        System.out.println(String.format("backChess1:%d | backChess2:%d | whiteChess:%d",
                backChess1.hashCode(), backChess2.hashCode(), whiteChess.hashCode()));
    }

    public static void main(String[] args) {
        FlyweightClient flyweightClient = new FlyweightClient();
        flyweightClient.playChess();
    }
}

从输出可见，backChess1 与 backChess2 是同一个对象，而whiteChess是另一个不同的对象。所以不论棋盘上有多少颗棋子，程序中只会保持最多两个棋子对象，这就极大的节约了内存 

 总结

• 首先一定要区分出内部状态与外部状态，共享对象只持有内部状态，内部状态不可以从客户端设置，而外部状态必须从客户端设置。
• 合理设计共享对象分类，大部分情况下会设计成一组，而不是一个共享对象。
• 共享对象要求是不可变对象，从FlyWeightFactory获取到的对象都是一个原始的对象，而不是一个状态不确定的对象

https://shusheng007.top/2021/09/08/022/