在介绍享元模式之前，先来看一个问题。假设要你去做一款扑克牌游戏，你会针对扑克牌设计一种怎样的数据结构呢？
因为扑克牌有四种花色，也即红桃(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 个对象，一个是代表黑棋的对象，一个是代表白棋的对象。而如果我们没用利用这种模式呢？简直不敢想象。
我所理解的享元模式全都展现在这个例子当中，如果有不恰当之处，往看到该文章的人多多指教，大家互相学习。