认识达内从这里开始

下面JAVA培训机构老师带大伙来看看,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 : 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个对象，一个是代表黑棋的对象，一个是代表白棋的对象。而如果我们没用利用这种模式呢？简直不敢想象。

Java设计模式--享元模式

关于Java设计模式中享元模式的学习，JAVA培训机构老师就给大家分享到这里了，后期还会有更多内容分享给大家，不要错过噢！