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

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

你可能感兴趣的:(Java 设计模式 -- 享元模式)