Java 设计模式 -- 享元模式

在介绍享元模式之前，先来看一个问题。假设要你去做一款扑克牌游戏，你会针对扑克牌设计一种怎样的数据结构呢？

因为扑克牌有四种花色，也即红桃(Heart),黑桃（Spade），方块（Diamond ），梅花（Club），有 13 种不同的大小，也即 A - K ， 还有大小王，所以这个类应该很好设计，代码如下所示

public final class Global {    public static final int HEART = 0;    public static final int SPADE = 1;    public static final int DIAMOND = 2;    public static final int CLUB = 3;}    public class Card {        private int mCardColor;        private int mCardFigure;        public Card() {        }        public Card(int cardColor, int cardFigure) {            this.mCardColor = cardColor;            this.mCardFigure = cardFigure;        }        public int getCardColor() {            return mCardColor;        }        public void setCardColor(int cardColor) {            mCardColor = cardColor;        }        public int getFigure() {            return mCardFigure;        }        public void setFigure(int cardFigure) {            mCardFigure = cardFigure;        }}

这样的话，扑克牌游戏一开始，就将该类实例化 54 次，因为扑克牌共有54张。看似问题解决了，但是仔细想想，这么做是不是太浪费空间了？因为每张扑克牌除了花色和大小不一样，其他的不都一样吗？为什么要浪费内存存储 54个对象呢？但是，如果不这么做，我们又能怎么做呢？

实际上，解决上述问题是享元模式最拿手的，换种说法，享元模式也正是因为这种问题诞生的。享元模式提供的解决问题的思想就是共享，通过利用共享对象替换再次申请对象。

回到刚才扑克牌的问题，如果利用享元模式该怎么设计呢？既然每张扑克牌除了颜色和大小之外完全相同，那么我们就将这两种属性抽象出来考虑，我们可以将 Card 类设置成抽象类，四种不同的花色继承 Card，如下所示

public abstract class Card {    abstract void display(String cardFigure);}public class ClubCard extends Card {    public ClubCard() {        super();    }    @Override    void display(String cardFigure) {        System.out.println("Club : " + cardFigure);    }}public class DiamondCard extends Card {    public DiamondCard() {        super();    }    @Override    void display(String cardFigure) {        System.out.println("Diamond : " + cardFigure);    }}public class HeartCard extends Card {    public HeartCard() {        super();    }    @Override    void display(String cardFigure) {        System.out.println("Heart : " + cardFigure);    }}public class SpadeCard extends Card {    public SpadeCard() {        super();    }    @Override    void display(String cardFigure) {        System.out.println("Spade : " + cardFigure);    }}

如上所示，这样我们就已经将颜色这一个属性从 Card 中抽象出来，这么做的好处是什么？好处就是对于每种颜色的扑克牌可以共用一个类，只需要改变 传进 display() 函数中的参数就可以表示扑克牌中的所有值。在享元模式中，这种情况还分别有名字，保存在享元池中的对象是内部状态，内部状态是不可改变的，也即具有不变性和通用性。而对于我们从享元池中取出的对象，我们是可以改变的，这时候的状态又被称为外部状态。

下面来看看享元模式下是如何创建对象的

public class CardContainer {    private static CardContainer container = new CardContainer();    public HashMap<Integer, Card> mMap = new HashMap<>();    public Card getCard(int cardColor) {        if (mMap.containsKey(cardColor)) {            return (Card) mMap.get(cardColor);        } else {            Card card = CardFactory.newCard(cardColor);            mMap.put(cardColor, card);            return card;        }    }    public static CardContainer newInstance() {        return container;    }}

如上所示，首先 为了确保 CardContainer 只有一个实例，固用利用单例模式来对其进行设计，为了方便对各个花色的扑克牌进行创建，还利用简单工厂模式设计了一个 CardFactory 类，如下所示

public class CardFactory {    public static Card newCard(int cardColor){        if(Global.CLUB == cardColor) return new ClubCard();        else if(Global.HEART == cardColor) return new HeartCard();        else if(Global.DIAMOND == cardColor) return new DiamondCard();        else if(Global.SPADE == cardColor) return new SpadeCard();        return null;    }}

下面来对CardContainer 进行测试

public class Client {    public static void main(String[] args) {        CardContainer container = CardContainer.newInstance();        Card heartCardA = container.getCard(Global.HEART);        Card diamonCardA = container.getCard(Global.DIAMOND);        Card spadeCardA = container.getCard(Global.SPADE);        Card clubCardA = container.getCard(Global.CLUB);        heartCardA.display("A");        diamonCardA.display("A");        spadeCardA.display("A");        clubCardA.display("A");    }}

输出结果如下所示

Heart : ADiamond : ASpade : AClub : A

当然，我们的目的不仅仅是这样，而是为了相同的花色共用一个对象，这个效果有没有达到呢，再添加几行代码如下所示

Card heartCardJ = container.getCard(Global.HEART);heartCardJ.display("J");System.out.println(heartCardA == heartCardA);

结果正如期望的那样，输出了

Heart : Jtrue

这也就意味着，如果将大小王分别归类为红桃黑桃，我们只需要 4 个对象就可以表示 54 张扑克牌，对比与之前的 54 个对象，可谓天壤之别。更何况，这还只是针对扑克牌的情况，如果是下围棋呢？利用享元模式我们只需要 2 个对象，一个是代表黑棋的对象，一个是代表白棋的对象。而如果我们没用利用这种模式呢？简直不敢想象。

我所理解的享元模式全都展现在这个例子当中，如果有不恰当之处，往看到该文章的人多多指教，大家互相学习。