如何在Deck类中引入Card类并完成牌组初始化？

嘿，我明白你现在困惑的点——怎么把Card类和Deck类结合起来，让Deck能正确生成一副完整的牌组对吧？别担心，咱们一步步拆解来做，完全贴合你的任务要求：

核心思路：在Deck构造中生成Card实例 #

Deck类的cards数组是Card类型的，所以我们要在Deck的构造方法里，遍历所有花色和点数，创建对应的Card对象并填充到数组里。首先得给Deck补上点数和对应值的数组，因为一副牌每个花色有13个点数嘛。

1. 完善Deck的构造方法 #

首先给Deck类添加点数数组和对应的值数组，然后在构造方法里循环生成52张牌：

class Deck {
    private Card[] cards;
    private int size;
    private String[] suits = {"Clubs","Diamonds","Hearts","Spades"};
    // 添加点数和对应的值数组
    private String[] ranks = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King", "Ace"};
    private int[] values = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};

    public Deck() {
        size = 52;
        cards = new Card[size];
        int index = 0;
        // 遍历每个花色
        for (String suit : suits) {
            // 遍历每个点数，生成对应Card
            for (int i = 0; i < ranks.length; i++) {
                cards[index] = new Card(suit, ranks[i], values[i]);
                index++;
            }
        }
        // 构造方法里调用洗牌方法
        shuffle();
    }
    // ...其他方法
}

这里的逻辑很简单：每个花色对应13个点数，循环嵌套就能生成所有52张牌，把每个新创建的Card对象放到cards数组的对应位置。

2. 实现私有shuffle方法 #

按照要求，我们要做1000次随机交换来洗牌：

private void shuffle() {
    for (int i = 0; i < 1000; i++) {
        // 生成两个0-51的随机索引
        int idx1 = (int)(Math.random() * 52);
        int idx2 = (int)(Math.random() * 52);
        // 交换两张牌
        Card temp = cards[idx1];
        cards[idx1] = cards[idx2];
        cards[idx2] = temp;
    }
}

注意shuffle方法要加返回类型void，之前你的代码里漏了这个细节。

3. 重写Deck的toString方法 #

要利用Card已经写好的toString方法，我们可以用StringBuilder来拼接所有牌的信息，这样效率更高：

@Override
public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append("Deck (size: ").append(size).append(")\n");
    for (int i = 0; i < cards.length; i++) {
        sb.append(cards[i].toString());
        // 每4张牌换行，方便阅读
        if ((i + 1) % 4 == 0) {
            sb.append("\n");
        } else {
            sb.append(" ");
        }
    }
    return sb.toString();
}

这里直接调用cards[i].toString()就能复用Card类已经实现的格式，完美符合任务要求。

完整的代码整合 #

把所有部分拼起来，完整的可运行代码是这样的：

public class Lab11bvst {
    public static void main(String[] args) {
        Deck deck = new Deck();
        System.out.println(deck);
    }
}

class Deck {
    private Card[] cards;
    private int size;
    private String[] suits = {"Clubs","Diamonds","Hearts","Spades"};
    private String[] ranks = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King", "Ace"};
    private int[] values = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};

    public Deck() {
        size = 52;
        cards = new Card[size];
        int index = 0;
        for (String suit : suits) {
            for (int i = 0; i < ranks.length; i++) {
                cards[index] = new Card(suit, ranks[i], values[i]);
                index++;
            }
        }
        shuffle();
    }

    private void shuffle() {
        for (int i = 0; i < 1000; i++) {
            int idx1 = (int)(Math.random() * 52);
            int idx2 = (int)(Math.random() * 52);
            Card temp = cards[idx1];
            cards[idx1] = cards[idx2];
            cards[idx2] = temp;
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Deck (size: ").append(size).append(")\n");
        for (int i = 0; i < cards.length; i++) {
            sb.append(cards[i].toString());
            if ((i + 1) % 4 == 0) {
                sb.append("\n");
            } else {
                sb.append(" ");
            }
        }
        return sb.toString();
    }
}

class Card {
    private String suit;
    private String rank;
    private int value;

    public Card(String s, String r, int v) {
        suit = s;
        rank = r;
        value = v;
    }

    public String getSuit() { return suit; }
    public String getRank() { return rank; }
    public int getValue() { return value; }

    public void setSuit(String s) { suit = s; }
    public void setRank(String r) { rank = r; }
    public void setValue(int v) { value = v; }

    @Override
    public String toString() { return "[" + suit + ", " + rank + ", " + value + "]"; }

    public boolean matches(Card otherCard) {
        return otherCard.getSuit().equals(this.suit) && otherCard.getRank().equals(this.rank) && otherCard.getValue() == this.value;
    }
}

关键要点总结 #

• 整合核心：Deck作为Card的容器，直接在构造方法中创建Card实例来填充自己的cards数组，这就是两者整合的核心逻辑。
• 复用toString：Deck的toString不需要重复造轮子，直接调用每个Card的toString方法即可，减少代码冗余。
• 私有shuffle：作为内部辅助方法，只在Deck构造时调用，负责完成牌组的打乱操作。

内容的提问来源于stack exchange，提问作者HNY