1. Hand 类与 Card 对象的职责分离
1.1 设计要点
在面向对象设计中，Hand 作为牌组的容器，与 Card 对象之间形成清晰的组合关系。这种分工使得牌面的表现与牌组的管理各自独立，提升了系统的可维护性与扩展性。通过将
下面给出一个简化的类型设计，帮助理解 Hand 如何持有 Card 对象的集合，以及 Card 本身应具备的基本能力：数据封装、只读访问、以及不可变卡牌对象。这些要点有利于提升代码的健壮性与可读性。
public enum Suit { HEARTS, DIAMONDS, CLUBS, SPADES; }public enum Rank {TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN,JACK, QUEEN, KING, ACE
}public class Card {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; }@Overridepublic String toString() {return rank + " of " + suit;}
}
通过上述设计，Card 成为了一个不可变对象，而 Hand 则负责组合管理。为了进一步实现封装性，可以在 Hand 内部维护一个私有列表，并对外提供受控的访问方式。
public class Hand {private final List cards = new ArrayList<>();public void addCard(Card c) { cards.add(c); }public Card getCard(int index) { return cards.get(index); }public List getCards() {return Collections.unmodifiableList(cards);}@Overridepublic String toString() {return cards.toString();}
}
1.2 Hand 与 Card 的协作方式
通过上面的实现，Hand 负责管理
在实际编码中，常见的协作思路包括：直接通过 hand.getCard(index) 获取 Card 再调用其方法，或通过遍历 hand.getCards() 对每张牌执行需要的逻辑。
2. 通过 Hand 调用 Card 的常用模式
2.1 直接访问 Card 的 Getter 方法
最直接的方式是通过 Hand 提供的入口获取 Card，再对 Card 的 Getter 进行调用。这种方式简单直观，适用于需要逐张牌分析的场景。示例中的核心步骤是：先取得 Card，再调用其 getRank 或 getSuit，从而获得牌面的信息。
Hand hand = new Hand();
hand.addCard(new Card(Rank.ACE, Suit.SPADES));
Card first = hand.getCard(0);
Rank rank = first.getRank();
Suit suit = first.getSuit();
System.out.println("牌面: " + rank + " of " + suit);
在这段代码中，hand.getCard(0) 返回一个 Card 对象，随后对 Card 调用 getRank 与 getSuit，从而获得牌面的两个维度信息。通过这样的方式，Hand 成为 Card 的入口点。
2.2 通过 Hand 的中间方法间接调用 Card
除了直接获取 Card 再调用其方法，有时我们会在 Hand 中提供更高层次的操作，例如直接“打出”一张牌，或对牌组进行基于外部业务逻辑的处理。此时，可以在 Hand 中实现像 playCard 之类的中间方法，返回被移除的 Card，调用端就无需直接操作 Card。
public class Hand {private final List cards = new ArrayList<>();public Card playCard(int index) {return cards.remove(index);}
}
使用时的示例：
Card played = hand.playCard(2);
System.out.println("打出牌: " + played);
通过中间方法，调用方可以在不直接操作内部 Card 集合的情况下完成常规操作，提升代码的可维护性与可测试性。
2.3 遍历手牌并调用 Card 的方法
对手牌进行遍历时，可以直接对每张 Card 调用其方法，获得统一的处理结果。这里的核心点是：Hand 提供了对 Card 集合的可控访问，让调用方可以简洁地完成遍历与处理。
for (Card c : hand.getCards()) {System.out.println(c.getRank() + " " + c.getSuit());
}
遍历能力让我们在保持封装性的同时，实现对整副牌的批量处理，极大提升了代码的可读性与可扩展性。
3. 实用示例：构建手牌并计算牌面分数
3.1 示例：构建手牌并统计点数
在一些纸牌游戏中，计算牌面的分数是最常见的需求之一。利用 Hand 与 Card 的组合，我们可以快速实现一个分数统计函数，核心思路是遍历 Card 集合并对 Rank 进行映射。重点在于正确遍历与对每张牌的 Rank 进行累计。
public int sumRankPoints(Hand hand) {int sum = 0;for (Card c : hand.getCards()) {switch (c.getRank()) {case ACE: sum += 11; break;case KING: case QUEEN: case JACK: sum += 10; break;default: sum += c.getRank().ordinal() + 2; // 简易映射}}return sum;
}
这段实现演示了如何在保持 Card 封装的前提下，利用 Hand 的接口完成跨对象的业务逻辑。
3.2 示例：实际使用手牌计算分数
接下来给出一个完整的使用场景：
Hand hand = new Hand();
hand.addCard(new Card(Rank.ACE, Suit.HEARTS));
hand.addCard(new Card(Rank.TEN, Suit.DIAMONDS));int score = sumRankPoints(hand);
System.out.println("总点数: " + score);
实际输出会显示当前手牌的总分数，演示了 Hand 与 Card 在业务逻辑中的协作能力。
4. 注意事项与异常处理
4.1 空指针与越界检查
在访问 Hand 内部的 Card 时，越界或空集合的情况是最常见的错误来源。为了保证健壮性，调用方应在访问之前进行检查，或 Hand 提供安全的访问接口来避免直接暴露内部实现。
try {Card c = hand.getCard(0);// 进一步处理
} catch (IndexOutOfBoundsException ex) {System.out.println("手牌为空，无法访问牌。");
}
防御式编程是确保游戏逻辑稳定运行的关键之一，特别是在多人交互或网络输入的场景下。
4.2 返回值与空对象的设计
若 Hand 的访问方法可能返回空值，优先考虑返回不可变的空对象或通过 Optional 提供明确的语义，而非直接返回 null。这里的核心要点是通过设计上下文语义来避免空指针异常。
5. 常见扩展与接口设计
5.1 为 Hand 添加迭代能力
为了提升遍历的自然性，可以让 Hand 实现 Iterable<Card>，从而支持在增强型 for 循环中直接使用 Hand。
public class Hand implements Iterable {private final List cards = new ArrayList<>();@Overridepublic Iterator iterator() {return cards.iterator();}
}
迭代能力使得对牌组的遍历更加直观，且有助于编写更简洁的业务逻辑。
5.2 实现可测试的对 Card 的封装
良好的测试覆盖是保障 Hand 与 Card 协作正确性的关键。通过对 addCard、getCard、playCard 等方法编写单元测试，可以在不暴露实现细节的情况下验证行为正确性。
@Test
public void testAddAndGetCard() {Hand hand = new Hand();Card c = new Card(Rank.ACE, Suit.SPADES);hand.addCard(c);assertEquals(c, hand.getCard(0));
}
测试用例设计应覆盖边界情况，例如空手牌、越界访问以及多张牌的顺序性等，以确保 Hand 调用 Card 的方式在各场景下都表现稳定。
