在介紹享元模式之前，先來看一個問題。假設要你去做一款撲克牌遊戲，你會針對撲克牌設計一種怎樣的資料結構呢？

因為撲克牌有四種花色，也即紅桃(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 : A
Diamond : A
Spade : A
Club : A

當然，我們的目的不僅僅是這樣，而是為了相同的花色共用一個物件，這個效果有沒有達到呢，再新增幾行程式碼如下所示

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

結果正如期望的那樣，輸出了

Heart : J
true

這也就意味著，如果將大小王分別歸類為紅桃黑桃，我們只需要 4 個物件就可以表示 54 張撲克牌，對比與之前的 54 個物件，可謂天壤之別。更何況，這還只是針對撲克牌的情況，如果是下圍棋呢？利用享元模式我們只需要 2 個物件，一個是代表黑棋的物件，一個是代表白棋的物件。而如果我們沒用利用這種模式呢？簡直不敢想象。

我所理解的享元模式全都展現在這個例子當中，如果有不恰當之處，往看到該文章的人多多指教，大家互相學習。