Java 21点OOP

我试图通过创建一个21点游戏来实现Java中OOP的最大潜力。到目前为止，我有5个java文件

Suit.java

enum Suit {

/*
 * Initialize suit values
 */
    HEARTS,
    SPADES,
    CLUBS,
    DIAMONDS;
}

Rank.java

enum Rank {

    /*
     * Initialize rank and card value
     */

    TWO(2),
    THREE(3), 
    FOUR(4), 
    FIVE(5), 
    SIX(6),
    SEVEN(7), 
    EIGHT(8), 
    NINE(9), 
    TEN(10), 
    JACK(10), 
    QUEEN(10),
    KING(10), 
    ACE(11);


    // Hold card value
    private int cardValue;

    /*
     * Constructor set card value
     * @param cardValue value of card
     */
    private Rank(int cardValue) {
        this.cardValue = cardValue;
    }

    /*
     * This method obtains the card value
     * @return This returns the value of card
     */
    public int getCardValue() {
        return cardValue;
    }
}

java

public class Card {

    private Suit suit;
    private Rank rank;


    public Card(Rank rank, Suit suit) {
        this.rank = rank;
        this.suit = suit;
    }

    public Rank getCardValue() {
        return rank;
    }

    public Suit getSuitValue() {
        return suit;
    }
}

deck.java

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;


public class Deck {

    private ArrayList deck;

    public Deck() {

        this.deck = new ArrayList();

        for(Suit suit : Suit.values()) {
            for(Rank rank: Rank.values()) {
                Card card = new Card(rank, suit);
                this.deck.add(card);
            }
        }

        Collections.shuffle(deck);
    }

    public ArrayList getDeck() {
        return deck;
    }
}

Game.java

import java.util.ArrayList;
import java.util.Iterator;

public class Game {

    public static void main(String[] args) {

        Deck deck = new Deck();

        for(int i=0; i<deck.getDeck().size(); i++) {

            System.out.println( ((Card)   deck.getDeck().get(i)).getCardValue() + " of " 
            + ((Card) deck.getDeck().get(i)).getSuitValue() );
        }
    }
}

import java.util.ArrayList；
导入java.util.Iterator；
公开课游戏{
公共静态void main（字符串[]args）{
甲板=新甲板（）；
对于（int i=0；i int getCardValue（）而不是（Card.java）->Rank getCardValue（）？是否需要执行一些多态性？扩展？我希望int值而不是文本值

谢谢！
要回答您的直接问题，您只需简单地链接方法：

Card myCard = new Card(Rank.TWO, Suit.HEARTS);
int value = myCard.getCardValue().getCardValue();

第一个
getCardValue（）
调用返回一个Rank对象，下一个
getCardValue（）
get是Rank的值。但这让我很困惑，两个同名的方法返回不同的类型。我自己，我会将Card的
getCardValue（）
重命名为更直接、更符合逻辑的
getRank（）
和Rank的
getCardValue（）
更简单的
getValue（）
。这样代码看起来更符合逻辑：

int value = myCard.getRank().getValue();

至于你的另一个问题，“设计还可以吗”，这对这个网站来说太宽泛了，但我认为你使用继承很好，你不想过度使用继承，并且在你做的时候坚持使用组合。我还要说，你需要考虑ACE有两个可能的值，1和11

例如，可能类似于：

public enum Rank {

    TWO(2, 0, false), 
    THREE(3, 0, false), 
    FOUR(4, 0, false), 
    FIVE(5, 0, false), 
    SIX(6, 0, false), 
    SEVEN(7, 0, false), 
    EIGHT(8, 0, false), 
    NINE(9, 0, false), 
    TEN(10, 0, false), 
    JACK(10, 0, false), 
    QUEEN(10, 0, false), 
    KING(10, 0, false), 
    ACE(11, 1, true);

    private int value;
    private int value2;
    private boolean twoValues;

    private Rank(int value, int value2, boolean twoValues) {
        this.value = value;
        this.value2 = value2;
        this.twoValues = twoValues;
    }

    public int getValue() {
        return value;
    }

    public int getValue2() {
        // TODO: consider throwing a custom exception if twoValues is false
        return value2;
    }

    public boolean hasTwoValues() {
        return twoValues;
    }
}

只是想抛出一些备选方案：我可能会以不同的方式对排名的值进行建模。因为
ace
实际上没有一个确定的值。一个
Hand
有一个值，但即使它实际上也有一个“最佳值”，这可能算作
ace
11或1

因此，我可能会删除秩的值，并引入一个
手
：

public-class-Hand{
私人手牌（收集卡）{
...
}
private int calculateBestValue（）{
...
}
}

我也不会公开这个值的计算。
Hand
可以“呈现”自己，所以它也可以说你是否有一个“软”值

我还认为
Deck
不应该有一个
getDeck（）
方法。这违反了封装。相反，它应该有一个名为：
nextCard（）
的方法。该方法将从卡片组顶部为您提供下一张卡片。它可能需要一个
isEmpty（）
方法，该方法返回牌组是否有牌。
对于本网站来说，这可能不是一个合适的问题。话虽如此，您将如何处理ACE排名1和11的潜在双重值？是的，对于这个问题，一个更好的地方是获取排名，只需使用
getRank（）
并对返回的对象调用
getValue（）
。。或者不管您给这些方法起什么名字。在类
Deck
中使用泛型：
ArrayList
，而不是
ArrayList
。谢谢。我还使用了两次getCardValue（）。我刚刚将Rank版本更改为getRank（）。