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 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 个对象，一个是代表黑棋的对象，一个是代表白棋的对象。而如果我们没用利用这种模式呢？简直不敢想象。

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