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

Question

我正在努力完成这项作业，但到目前为止有点具有挑战性，我对 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()));
            }
        }
    }
}

我根据到目前为止所得到的内容更新了我的代码。

Answer 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
}