源代码：https://gitee.com/AgentXiao/MyFlyWeight
要点：
1、享元模式解决的问题
2、享元模式的核心及实现
3、享元模式的优缺点

一、引入场景

在围棋软件中，每一个棋子都是一个对象，按照普通的思路，当棋子改变位置时，需要再次new一个新的棋子对象，这就非常的浪费空间了。

但是我们都知道，真正下棋的时候，移动的是同一个棋子，也就说如果棋子移动时仍然是同一个对象，就能够大大地节省空间了。

享元模式就是在有很多个完全相同或相似的对象时，可以通过享元模式节省内存。

二、享元模式的核心

享元模式以共享的方式高效地支持大量细粒度对象的重用。

享元对象能做到共享的关键是区分了内部状态和外部状态。
• 内部状态：可以共享，不会随环境变化而改变。例如棋子的颜色、大小、形状。
• 外部状态：不可以共享，会随环境变化而改变。如棋子的位置。

三、享元模式的实现核心

享元模式

1、FlyweightFactory享元工厂类

• 创建并管理享元对象，享元池一般设计成键值对用于存储。

2、FlyWeight抽象享元类

• 通常是一个接口或抽象类，声明公共方法，这些方法可以向外界提供对象内部状态，设置外部状态。

3、ConcreteFlyWeight具体享元类

• 为内部状态提供成员变量进行存储。

4、UnsharedConcreteFlyWeight非共享享元类

• 不能被共享的子类可以设计为非共享享元类。

四、代码实现模拟围棋

1、FlyWeight抽象享元类：抽象棋子类

/**
 * @InterfaceName AbstractChess
 * @Description FlyWeight抽象享元类：抽象棋子类
 * @Author xwd
 * @Date 2018/10/25 12:45
 */
public interface AbstractChess {
    /**
     * @MethodName display
     * @Descrition 下棋到指定位置
     * @Param [coordinate]
     * @return void
     */
    void display(Coordinate coordinate);
}

2、ConcreteFlyWeight具体享元类：棋子

注意在display方法中，持有了Coordinate类的引用。

/**
 * @ClassName Chess
 * @Description ConcreteFlyWeight具体享元类：棋子
 * @Author xwd
 * @Date 2018/10/25 12:47
 */
public class Chess implements AbstractChess{
    //内部状态：颜色和大小
    private String color;
    private String num;

    public Chess(String color, String num) {
        this.color = color;
        this.num = num;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }

    @Override
    public void display(Coordinate coordinate) {
        System.out.println("将颜色为 "+this.color+" 大小为 "+this.num+" 的棋子放置到（"
                            +coordinate.getX()+","+coordinate.getY()+"）上");
    }
}

3、UnsharedConcreteFlyWeight非共享享元类：棋子位置

/**
 * @ClassName Coordinate
 * @Description UnsharedConcreteFlyWeight非共享享元类：棋子位置
 * @Author xwd
 * @Date 2018/10/25 12:47
 */
public class Coordinate {
    private int x,y;

    public Coordinate(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

4、FlyweightFactory享元工厂类:棋子工厂（核心）

/**
 * @ClassName ChessFactory
 * @Description FlyweightFactory享元工厂类:棋子工厂
 * @Author xwd
 * @Date 2018/10/25 12:52
 */
public class ChessFactory {
    //享元池
    private static Map map = new HashMap();

    public static Chess getChess(String color,String num){
        String msg = color+"_"+num;

        //如果享元池中已经存在，直接返回；否则创建一个新的
        if(map.get(msg) != null){
            return map.get(msg);
        }else{
            Chess newChess = new Chess(color,num);
            map.put(color+"_"+num,newChess);
            return newChess;
        }
    }
}

5、测试

/**
 * @ClassName Client
 * @Description 客户
 * @Author xwd
 * @Date 2018/10/25 13:08
 */
public class Client {
    public static void main(String[] args) {
        Chess chess1 = ChessFactory.getChess("黑色","5");
        Chess chess2 = ChessFactory.getChess("黑色","5");

        //获得的是同一个对象
        System.out.println(chess1);
        System.out.println(chess2);

        chess1.display(new Coordinate(20,60));
        chess1.display(new Coordinate(40,80));

        Chess chess3 = ChessFactory.getChess("白色","15");
        chess3.display(new Coordinate(88,65));
    }
}

6、测试结果

测试结果

由测试结果可以知道，我们建立了一个享元池，从中取相同具备相同内部状态的对象时取到的是同一对象。这就在一定程度上避免了对象的不断创建！

五、总结

1、使用的场景

享元模式由于其共享的特性，可以在任何“池”中操作，比如：线程池、数据库连接池、JVM中的常量池。

2、优点

极大减少内存中对象的数量。
相同或相似对象内存中只存一份，极大的节约资源，提高系统性能。
外部状态相对独立，不影响内部状态。

3、缺点

模式较复杂，使程序逻辑复杂化。
为了节省内存，共享了内部状态，分离出外部状态，而读取外部状态使运行时间变长（外部状态仍然需要不断创建对象）。用时间换取了空间。

【Java设计模式】结构型模式-享元模式