我正在 Java 编写纸牌游戏。玩家 2 的 Hands class 的第二个对象为玩家提供了与玩家 1 相同的牌组，为什么？

Question

我是编程初学者，这是我的第一个问题。我必须在 Java.

中编写纸牌游戏 Gin Rummy

我创建了卡片 class、牌组 class 和手牌 class。 deck class 构造函数初始化一个包含 52 张卡片的 Arraylist。在游戏开始时，每个玩家必须抓取 10 张牌，因此在 hands class 构造函数中，牌组的前 10 张牌被抓取并添加到 Hands class 中的数组列表中。

当我检查第一张球员卡时，这是真的。玩家 1 抽取 10 张牌后留在牌组中的牌？是的，卡片不再存在。玩家2卡？不对，玩家 2 的牌是 52 副牌的前 10 张牌（与玩家 1 相同）。我花了几个小时试图找出问题所在。

我在玩家 2 拿牌后打印了牌组，实际上抽到了前 20 张牌。我不知道为什么，当我创建 Hand class 的第二个对象时，它不会拿走接下来的 10 张牌，而是拿走第一个对象，玩家 1 已经拿过的牌。

这是 CardsDeck class：它将 52 张卡片集添加到数组列表中，效果很好。

     public class CardsDeck {

    private final int totalCardsNumber = 52;

 private static List<Card> deckOfCards;

    public CardsDeck(){
         deckOfCards = new ArrayList<>(totalCardsNumber);
         int index=0;
         for (int suit = 0; suit <Card.Suit.values().length; suit++){
             for(int rank = 0; rank <Card.Rank.values().length; rank++){
              deckOfCards.add(new Card(Card.Rank.values()[rank], Card.Suit.values()[suit]));
              index++;
             }
         }
        // Collections.shuffle(deckOfCards);
        }


    public void print(){
        for (Card card: deckOfCards){ System.out.println(card);}
        }
    public void setDeckOfCards(List<Card> updatedDeckOfCards) { this.deckOfCards = new ArrayList<>(updatedDeckOfCards); }
    protected static List<Card> getDeckOfCards() {
        return deckOfCards;
    }

}

这是手 class:

public class CardsInHands extends CardsDeck{

 protected static List<Card> updatedCardList = new ArrayList<>(getDeckOfCards());
    protected List<Card> playerCards = new ArrayList<>();

    public CardsInHands(){ 
        for (int i=0; i<10; i++){
           playerCards.add(getDeckOfCards().get(i)); 
           updatedCardList.remove(0); 
        }
        setDeckOfCards(updatedCardList); 

    }


    public void printPlayerCards() {
        for (Card card: playerCards){ System.out.print(card + " - ");}
    }


    public List<Card> getPlayerCards() {
        return playerCards;
    }
    public void setPlayerCards(List<Card> playerCards) { this.playerCards = playerCards;}
    public void removeCard(int cardIndex){ playerCards.remove(cardIndex);}
    public void addCard(Card card){playerCards.add(card);}

为了完成，这是卡片 class:

  public class Card {
    public enum Rank {
        ACE(1),TWO(2), THREE(3), FOUR(4), FIVE(5),
        SIX(6), SEVEN(7), EIGHT(8), NINE(9),
        TEN(10),
        JACK(10), QUEEN(10), KING(10);
        int value;

        Rank(int value) { this.value = value; }
        public int getValue() { return value; }
    }

    public enum Suit {SPADES,HEARTS, CLUBS, DIAMONDS;}

    private final Rank rank;
    private final Suit suit;

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


    public Rank getRank() { return rank; }
    public Suit getSuit() { return suit; }
    public int getValue(){ return rank.getValue(); }

    public String toString(){
        return this.rank+ " of " +this.suit;
    }
}

这是我测试代码的主要方法：

 public class Runner {
    public static void main(String[] args){
    CardsDeck cards = new CardsDeck();
    //cards.print();


   CardsInHands playerOne = new CardsInHands();
   //playerOne.printPlayerCards(); //prints first 10 cards of the deck
   // cards.print(); //correct, first 10 cards are gone

   CardsInHands playerTwo = new CardsInHands();
   playerTwo.printPlayerCards(); //shows same 10 cards of player 1!
   //cards.print(); //correct, second set of 10 cards are gone

    }
}

谁能告诉我我做错了什么导致 Hands class 的第二个对象无法正常工作？

Answer 1

发生这种情况是因为您已将 deckOfCards 标记为静态，这意味着它是一个 class 级别变量。那里停止使用静态，问题将得到解决。

更多关于静态变量的信息。 https://beginnersbook.com/2013/04/java-static-class-block-methods-variables/#:~:text=Java%20Static%20Variables,the%20instances%20of%20the%20class.&text=Static%20variables%20are%20also%20known%20as%20Class%20Variables.

我正在 Java 编写纸牌游戏。玩家 2 的 Hands class 的第二个对象为玩家提供了与玩家 1 相同的牌组，为什么？

I am coding a card game in Java. The second object of the Hands class for player2 gives the player the same set of cards as player1, why?

java

oop

static

constructor

object