Question

我正在尝试创建一个可以从不同的类生成随机卡的纸牌游戏。问题是专用于随机卡的代码块很大。有没有办法将这部分代码传输到我的Card类并使用getter和setter在主程序中使用？或者有没有办法让生成随机卡的代码更简单？

主程序：

String NewCard = "";
int theSuit, theRank;

for(int i=0; i<1; i++) { 
theRank= (int)(Math.random()*13);
theSuit = (int)(Math.random()*5);

clsCard cardFace = new clsCard( theSuit, theRank);

NewCard =cardFace.toString();
System.out.println(" Your new card  is " + NewCard);

卡类：

public class clsCard {

    private int value;
    private int rank, suit;
    private final int MaxFaceValue= 10;
    private static String[] suits = {"Joker","hearts","spades","diamond","clubs"};
    private static String[] ranks = {"Joker","Ace","2","3","4","5","6","7","8","9","10","Jack","Queen","King"};

    public clsCard(int suit, int rank)
    {
        this.rank=rank;
        this.suit=suit;
    }

    public @Override String toString()
    {
        if(ranks[rank].equals("Joker") || suits[suit].equals("Joker"))
            return "Joker";
        else
            return ranks[rank] + " of " + suits[suit];
    }

    public int getRank()
    {
        return rank;
    }

    public int getSuit()
    {
        return suit;
    }
}

Answer 1

人们告诉你给你的卡一个生成随机卡的构造函数，我不同意。如果这是您的目标，选择随机卡，如果您的目标是让您的代码镜像现实，那么要正确解决这个问题，您需要另一个类Deck类，其中包含一组卡片，可能是List<Card>，ArrayList<>。然后你可以通过调用Collections.shuffle(cardList);来 shlole 套牌（它的集合），并通过调用它的.remove(0)方法从ArrayList中提取混洗后的卡片，该方法从第一张卡片中移除第一张卡片。收集并归还。

另请注意，此类程序通常用于教程中如何以及在何处使用枚举，因为卡片的套装和等级（或值）非常适合作为枚举。例如：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CardFun {
    public static void main(String[] args) {
        Deck deck = new Deck();
        for (int i = 0; i < 5; i++) {
            System.out.println(deck.deal());
        }
    }
}

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

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

    public int getValue() {
        return value;
    }

}

enum Suit {
    CLUBS, DIAMONDS, HEARTS, SPADES  
}

class Card {
    private Suit suit;
    private Rank rank;
    public Card(Suit suit, Rank rank) {
        this.suit = suit;
        this.rank = rank;
    }
    public Suit getSuit() {
        return suit;
    }
    public Rank getRank() {
        return rank;
    }

    @Override
    public String toString() {
        if (rank == Rank.JOKER) {
            return "joker";
        } 
        return "" + rank + " of " + suit;            
    }

    // equals and hashCode    
}

class Deck {
    private List<Card> cardList = new ArrayList<>();

    public Deck() {
        regenerate();
    }

    final public void regenerate() {
        cardList = new ArrayList<>();
        for (Suit suit : Suit.values()) {
            for (int i = 1; i < Rank.values().length; i++) {
                Rank rank = Rank.values()[i];
                Card card = new Card(suit, rank);
                cardList.add(card);
            }
        }
        Collections.shuffle(cardList);
    }

    public Card deal() {
        if (cardList.size() == 0) {
            // throw an exception
        }
        return cardList.remove(0);
    }
}

Answer 2

创建一个生成随机值的构造函数

 public clsCard() {
    this.rank= (int)(Math.random()*ranks.length);
    this.suit= (int)(Math.random()*suits.length);
}

在另一个班级

中制作new clsCard()

您还可以制作一些public static List<clsCard> generateCards(int amount)方法，以免污染您的主要方法。

然后你可以做

for (clsCard c : clsCard.generateCards(1)) {
    System.out.println(" Your new card  is " + c);
}

Answer 3

我可以想到两个选择：

您可以决定不带clsCard参数的构造函数会随机生成值，使用它：

public clsCard() {
    this.suit = (int)(Math.random() * suits.length);
    this.rank = (int)(Math.random() * ranks.length);
}

但这似乎有点武断。

您还可以在static中创建clsCard方法，以生成随机实例。

public static clsCard generateRandomCard() {
    return new clsCard((int)(Math.random() * suits.length), 
                       (int)(Math.random() * ranks.length));
}

顺便说一下，与您的问题无关的评论：您生成随机卡的方法实际上不会使每张卡中的52个中的1个（Jokers会更频繁地出现）。如果这很重要，你可能想要考虑一下。

如何将代码从程序转换为类（Getters和setter）

3 个答案: