修改 .java 文件以将常量更改为枚举答案

【问题标题】：Modify a .java file to change constants to enums修改 .java 文件以将常量更改为枚举
【发布时间】：2015-12-18 02:51:21
【问题描述】：

我正在努力完成这个作业，但到目前为止它有点挑战性，我对 java 还是很陌生：

1)。我必须创建枚举来替换 Card.java 中排名和花色的命名常量。

2).在 Deck.java 和 DisplayDeck.java 中进行必要的更改，以便它们可以与新的 Card.java 一起使用。

到目前为止，这是我的三个类的代码：Card.java、Deck.java 和 DisplayDeck.java

原创 Card.java

public class Card {
private final int rank;
private final int suit;

// Kinds of suits
public final static int DIAMONDS = 1;
public final static int CLUBS    = 2;
public final static int HEARTS   = 3;
public final static int SPADES   = 4;

// Kinds of ranks
public final static int ACE   = 1;
public final static int DEUCE = 2;
public final static int THREE = 3;
public final static int FOUR  = 4;
public final static int FIVE  = 5;
public final static int SIX   = 6;
public final static int SEVEN = 7;
public final static int EIGHT = 8;
public final static int NINE  = 9;
public final static int TEN   = 10;
public final static int JACK  = 11;
public final static int QUEEN = 12;
public final static int KING  = 13;

public Card(int rank, int suit) {
    assert isValidRank(rank);
    assert isValidSuit(suit);
    this.rank = rank;
    this.suit = suit;
}

public int getSuit() {
    return suit;
}

public int getRank() {
    return rank;
}

public static boolean isValidRank(int rank) {
    return ACE <= rank && rank <= KING;
}

public static boolean isValidSuit(int suit) {
    return DIAMONDS <= suit && suit <= SPADES;
}

public static String rankToString(int rank) {
    switch (rank) {
    case ACE:
        return "Ace";
    case DEUCE:
        return "Deuce";
    case THREE:
        return "Three";
    case FOUR:
        return "Four";
    case FIVE:
        return "Five";
    case SIX:
        return "Six";
    case SEVEN:
        return "Seven";
    case EIGHT:
        return "Eight";
    case NINE:
        return "Nine";
    case TEN:
        return "Ten";
    case JACK:
        return "Jack";
    case QUEEN:
        return "Queen";
    case KING:
        return "King";
    default:
        //Handle an illegal argument.  There are generally two
        //ways to handle invalid arguments, throwing an exception
        //(see the section on Handling Exceptions) or return null
        return null;
    }    
}

public static String suitToString(int suit) {
    switch (suit) {
    case DIAMONDS:
        return "Diamonds";
    case CLUBS:
        return "Clubs";
    case HEARTS:
        return "Hearts";
    case SPADES:
        return "Spades";
    default:
        return null;
    }    
}

public static void main(String[] args) {

    // must run program with -ea flag (java -ea ..) to
    // use assert statements
    assert rankToString(ACE) == "Ace";
    assert rankToString(DEUCE) == "Deuce";
    assert rankToString(THREE) == "Three";
    assert rankToString(FOUR) == "Four";
    assert rankToString(FIVE) == "Five";
    assert rankToString(SIX) == "Six";
    assert rankToString(SEVEN) == "Seven";
    assert rankToString(EIGHT) == "Eight";
    assert rankToString(NINE) == "Nine";
    assert rankToString(TEN) == "Ten";
    assert rankToString(JACK) == "Jack";
    assert rankToString(QUEEN) == "Queen";
    assert rankToString(KING) == "King";

    assert suitToString(DIAMONDS) == "Diamonds";
    assert suitToString(CLUBS) == "Clubs";
    assert suitToString(HEARTS) == "Hearts";
    assert suitToString(SPADES) == "Spades";

}


}

到目前为止我修改过的 Card.java：

public class Card {

   public enum Suit
   {
      DIAMONDS(1), 
      CLUBS(2), 
      HEARTS(3), 
      SPADES(4);

      private final int suit;

      private Suit(int suit)
      {
         this.suit = suit;
      }

      public int getSuit()
      {
         return suit;
      }
   } //end enum suit

   public enum Rank
   {
      ACE(1),
      DEUCE(2),
      THREE(3),
      FOUR(4),
      FIVE(5),
      SIX(6),
      SEVEN(7),
      EIGHT(8),
      NINE(9),
      TEN(10),
      JACK(11),
      QUEEN(12),
      KING(13);

      private final int rank;

      private Rank(int rank)
      {
         this.rank = rank;
      }

      public int getRank()
      {
         return rank;
      }
   }//end enum rank


    public static String rankToString(Rank rank) {
        switch (rank) {
        case ACE:
            return "Ace";
        case DEUCE:
            return "Deuce";
        case THREE:
            return "Three";
        case FOUR:
            return "Four";
        case FIVE:
            return "Five";
        case SIX:
            return "Six";
        case SEVEN:
            return "Seven";
        case EIGHT:
            return "Eight";
        case NINE:
            return "Nine";
        case TEN:
            return "Ten";
        case JACK:
            return "Jack";
        case QUEEN:
            return "Queen";
        case KING:
            return "King";
        default:
            //Handle an illegal argument.  There are generally two
            //ways to handle invalid arguments, throwing an exception
            //(see the section on Handling Exceptions) or return null
            return null;
        }    
    }

    public static String suitToString(Suit suit) {
        switch (suit) {
        case DIAMONDS:
            return "Diamonds";
        case CLUBS:
            return "Clubs";
        case HEARTS:
            return "Hearts";
        case SPADES:
            return "Spades";
        default:
            return null;
        }    
    }

    }//end class

这是原来的Deck.java和DisplayDeck.java：

原创 Deck.java

import java.util.*;

public class Deck {

    public static int numSuits = 4;
    public static int numRanks = 13;
    public static int numCards = numSuits * numRanks;

    private Card[][] cards;

    public Deck() {
        cards = new Card[numSuits][numRanks];
        for (int suit = Card.DIAMONDS; suit <= Card.SPADES; suit++) {
            for (int rank = Card.ACE; rank <= Card.KING; rank++) {
                cards[suit-1][rank-1] = new Card(rank, suit);
            }
        }
    }

    public Card getCard(int suit, int rank) {
        return cards[suit-1][rank-1];
    }
}

修改 Deck.java：

import java.util.*;

public class Deck {

    public static int numSuits = 4;
    public static int numRanks = 13;
    public static int numCards = numSuits * numRanks;

    private Card[][] cards;

    public Deck() {
        cards = new Card[numSuits][numRanks];
        for (Card.Suit suit : Card.Suit.values()) {
            for (Card.Rank rank : Card.Rank.values()) {
               // I dont know how to change this to work with Card.java
                cards[suit-1][rank-1] = new Card(rank, suit);
            }
        }
    }

    public Card getCard(int suit, int rank) {
        return cards[suit-1][rank-1];
    }
}

和 DisplayDeck.java

import java.util.*;

public class DisplayDeck {
    public static void main(String[] args) {
        Deck deck = new Deck();
        /// how can i modify this code to work with both Card.java and Deck.java?
        for (int suit = Card.DIAMONDS; suit <= Card.SPADES; suit++) {
            for (int rank = Card.ACE; rank <= Card.KING; rank++) {
                Card card = deck.getCard(suit, rank);
                System.out.format("%s of %s%n",
                    card.rankToString(card.getRank()),
                    card.suitToString(card.getSuit()));
            }
        }
    }
}

我更新了我目前得到的代码。

【问题讨论】：

您的问题是什么？你不是要我们做你的功课（对吧？），所以一定有一些具体的问题想让我们帮你解决。
是的，由于某种原因，我的最后一段没有出现。我的问题是：在原始 Card.java 文件中，每个 Suit 和 Rank“常量”变量都有一个 int 分配，我应该实现我的枚举，例如 DIAMONDS(1),CLUBS(2),HEARTS(3),SPADES(4) ;?
使用 .ordinal() 方法 (docs.oracle.com/javase/7/docs/api/java/lang/… ) 获取枚举内的索引。不要忘记替换一个，因为它从 0 开始。
它似乎没有出现，因为它不存在（如果您单击edit 选项，您将看到您的原始文本）。尝试添加缺少的部分并检查您是否没有收到任何错误/警告。

标签： java enums constants

【解决方案1】：

摆脱所有int 的等级和花色表示。您可以像这样替换循环：

for (int suit = Card.DIAMONDS; suit <= Card.SPADES; suit++) { ...

enhanced for loop:

for (Suit suit : Card.Suit.values()) { ...

根据需要将int 到String 的映射替换为EnumMap<Suit,String> 或EnumMap<Rank,String>。可以丢弃检查int 值是否有效的方法，因为非空enum 保证是合法值。

编辑（回应评论）：您可以将您的套牌简单地定义为 Card 对象的数组：

public class Deck {
    private List<Card> cards;

    public Deck() {
        cards = new ArrayList<>();
        for (Card.Suit suit : Card.Suit.values()) {
            for (Card.Rank rank : Card.Rank.values()) {
                cards.add(new Card(suit, rank));
            }
        }
    }
}

有了这个，您可以使用Collections 实用程序类来轻松实现洗牌：

public class Deck {
    . . . // as above
    public void shuffle() {
        Collections.shuffle(cards);
    }
}

因为每个enum 类型都带有一个内置的compareTo() 方法，它告诉您两个enum 值（相同类型）的相对顺序。您可以在此基础上使Card 类实现Comparable<Card>。（这留给读者作为练习:-)）。然后，您可以轻松地将牌组重新排序为“全新”顺序，甚至可以对从牌组中随机抽取的手牌进行分类。

我看到您目前正在按花色和等级检索一张牌。这是访问套牌中卡片的一种奇怪方式，尤其是因为您只需转身并使用Card 对象来检索其花色和等级。但是，如果您真的需要这种检索，您可以扩展 Deck 定义以在内部包含一个 EnumMap<Suit, EnumMap<Rank, Card>> 以允许您以这种方式快速检索卡。（是的，然后每张卡片将存储在 Deck 对象内的两个不同的数据结构中。）在我看来，更好的方法是添加一个方法来通过偏移量检索卡片到卡组中（以及另一种方法告诉你的甲板大小）：

public class Deck {
    . . .
    public Card getCard(int index) {
        return cards.get(index);
    }
    public int cardCount() {
        return cards.size();
    }
}

为了更漂亮，您可以定义一个方法，返回所有卡片的迭代器：

public class Deck {
    . . .
    public Iterator<Card> iterator() {
        return cards.iterator();
    }
}

更有趣的是，您可以声明 Deck 来实现 Iterable<Card>。然后您可以非常简单地打印卡片内容：

Deck deck = new Deck();
for (Card card : deck) {
    // print the card
}

【讨论】：

感谢您的宝贵时间和帮助。我更新了我的代码，但现在我不确定如何更改卡片[suit-1][rank-1] = new Card(rank, suit);在 Deck.java 上，因此它可以与我的新 Card.java 一起使用，以及如何修改 DiplayDeck.java 以同时适用于 Card 和 Deck 文件！谢谢！
@Jsch - 我扩展了我的答案以解决您的评论。