在介紹享元模式之前,先來看一個問題。假設要你去做一款撲克牌遊戲,你會針對撲克牌設計一種怎樣的數據結構呢?
因爲撲克牌有四種花色,也即紅桃(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 個對象,一個是代表黑棋的對象,一個是代表白棋的對象。而如果我們沒用利用這種模式呢?簡直不敢想象。
我所理解的享元模式全都展現在這個例子當中,如果有不恰當之處,往看到該文章的人多多指教,大家互相學習。