本文深入探讨了Java多米诺记忆游戏开发中常见的两个关键问题：对象比较不当导致的多米诺牌无法正确匹配，以及游戏状态（多米诺牌揭示状态）未及时更新导致游戏无法结束。通过详细解析 equals() 和 hashCode() 方法的正确覆写，以及在游戏逻辑中有效管理对象状态，本教程旨在帮助开发者构建功能完善、逻辑严谨的Java记忆游戏。
1. 问题分析与根源
在开发基于对象的记忆游戏时，两个常见的问题可能导致游戏行为异常：
- 对象比较不准确： 当需要判断两个游戏元素（如多米诺牌）是否“相等”时，如果仅仅使用 == 运算符，它会比较对象的内存地址，而非其内部属性值。这导致即使两张多米诺牌的数字相同，程序也可能认为它们不匹配。此外，即使尝试使用 equals() 方法，如果该方法在自定义类中未被正确覆写，其默认行为通常与 == 相同，即比较引用。
- 游戏状态未更新： 游戏元素的内部状态（例如多米诺牌是否已被揭示）未能根据游戏规则及时更新。这会导致即使玩家猜对了，多米诺牌也不会保持翻开状态，进而影响游戏结束条件的判断。
针对上述问题，我们将以一个Java多米诺记忆游戏为例，详细讲解如何通过覆写 equals() 和 hashCode() 方法以及正确管理对象状态来解决这些问题。
2. 解决对象比较问题：覆写 equals() 和 hashCode()
在Java中，当我们需要根据对象的实际内容（而非内存地址）来判断它们是否相等时，必须在自定义类中覆写 Object 类的 equals() 方法。同时，为了遵循Java约定和确保集合类（如 HashMap, HashSet）的正确行为，当覆写 equals() 时，也必须覆写 hashCode() 方法。
2.1 覆写 Domino.equals() 方法
原始的 Domino 类中的 equals() 方法存在逻辑错误：它只检查 top 和 bottom 是否相等，这导致只有双面牌（如 [2][2]）才会被认为是相等的，而不同位置但值相同的牌则无法匹配。
public boolean equals(Domino other) { // 错误的覆写方式 if (top == bottom) // 错误：只检查自身是否为双面牌 return true; return false; }
正确的 equals() 覆写应该比较当前 Domino 对象与传入的 Object 对象（在类型转换后）的 top 和 bottom 属性。
立即学习“Java免费学习笔记（深入）”；
@Override public boolean equals(Object obj) { // 1. 检查是否是同一个对象的引用 if (this == obj) { return true; } // 2. 检查传入对象是否为null或类型不匹配 if (obj == null || getClass() != obj.getClass()) { // 或者使用 !(obj instanceof Domino) return false; } // 3. 类型转换 final Domino other = (Domino) obj; // 4. 比较关键属性 if (this.getTop() != other.getTop()) { return false; } if (this.getBottom() != other.getBottom()) { return false; } return true; }
注意事项：
- @Override 注解是可选的，但强烈建议使用，它能帮助编译器检查你是否正确覆写了父类方法。
- equals() 方法的参数类型必须是 Object，否则它不是真正的覆写，而是一个重载方法。
- 在比较属性时，考虑到 Domino 构造函数已经保证了 top
2.2 覆写 Domino.hashCode() 方法
根据Java约定，如果两个对象通过 equals() 方法判断为相等，那么它们的 hashCode() 方法必须返回相同的值。覆写 hashCode() 的目的是为相等的对象生成一致的哈希码，这对于基于哈希的集合（如 HashMap, HashSet）的正确运行至关重要。
@Override public int hashCode() { int hash = 7; // 任意一个非零常数 hash = 59 * hash + this.getTop(); // 将属性值纳入哈希计算 hash = 59 * hash + this.getBottom(); return hash; }
注意事项：
- 哈希码的计算应基于参与 equals() 比较的所有属性。
- 使用质数（如59）进行乘法运算有助于减少哈希冲突。
- 一个好的 hashCode() 实现应尽可能地将不相等的对象分散到不同的哈希桶中。
3. 解决游戏状态更新问题：更新 guess() 方法
多米诺牌在匹配成功后未能保持揭示状态，是因为 Domino 对象的 revealed 属性没有被设置为 true。这个状态更新的逻辑应该发生在 MemoryLane 类的 guess() 方法中，当判断两张牌匹配成功时。
原始的 guess() 方法：
public boolean guess(int i, int k) { if(board[i] == board[k]) { // 错误：使用 == 比较对象引用 return true; } return false; }
修正后的 guess() 方法不仅要使用 equals() 进行对象内容比较，还要在匹配成功后调用 setRevealed(true) 来更新多米诺牌的状态。
public boolean guess(int i, int k) { // 使用覆写后的 equals 方法进行内容比较 if (board[i].equals(board[k])) { // 如果匹配成功，设置这两张多米诺牌为已揭示状态 board[i].setRevealed(true); board[k].setRevealed(true); return true; } // 如果不匹配，不需要做任何状态改变，直接返回false return false; }
4. 简化 isRevealed() 方法
在 Domino 类中，isRevealed() 方法可以简化，因为它本质上只是返回 revealed 字段的值。
原始的 isRevealed()：
public boolean isRevealed() { if (revealed) return true; return false; }
简化后的 isRevealed()：
public boolean isRevealed() { return revealed; }
5. 完整代码示例（修正后的关键类）
以下是经过上述修正后的 Domino 类和 MemoryLane 类中 guess 方法的关键代码片段。MemoryLaneDriver 类保持不变，因为它已经能够正确调用游戏逻辑。
5.1 修正后的 Domino 类
public class Domino { private int top, bottom; private boolean revealed; public Domino(int x, int y) { if (x > y) { top = y; bottom = x; } else { top = x; bottom = y; } } public int getTop() { return top; } public int getBottom() { return bottom; } public boolean isRevealed() { return revealed; // 简化后的方法 } public void setRevealed(boolean revealed) { this.revealed = revealed; } @Override public int hashCode() { int hash = 7; hash = 59 * hash + this.getTop(); hash = 59 * hash + this.getBottom(); return hash; } @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null || getClass() != obj.getClass()) { return false; } final Domino other = (Domino) obj; if (this.getTop() != other.getTop()) { return false; } if (this.getBottom() != other.getBottom()) { return false; } return true; } }
5.2 修正后的 MemoryLane 类（仅展示 guess 方法）
import java.util.Arrays; import java.util.Random; public class MemoryLane { private Domino[] board; public MemoryLane(int max) { board = new Domino[(max * max) + max]; int i = 0; for (int top = 1; top <= max; top++) { for (int bot = 1; bot <= max; bot++) { if (top <= bot) { board[i] = new Domino(top, bot); i++; board[i] = new Domino(top, bot); i++; } } } shuffle(); } private void shuffle() { int index; Random random = new Random(); for (int i = board.length - 1; i > 0; i--) { index = random.nextInt(i + 1); if (index != i) { Domino temp = board[index]; board[index] = board[i]; board[i] = temp; } } } // 修正后的 guess 方法 public boolean guess(int i, int k) { if (board[i].equals(board[k])) { // 使用覆写后的 equals 方法 board[i].setRevealed(true); // 设置为已揭示 board[k].setRevealed(true); // 设置为已揭示 return true; } return false; } public String peek(int a, int b) { String text = ""; // 可以直接初始化为空字符串 text += ("[" + board[a].getTop() + "] [" + board[b].getTop() + "]n"); text += ("[" + board[a].getBottom() + "] [" + board[b].getBottom() + "]n"); return text; } public boolean gameOver() { int count = 0; for (int i = 0; i < board.length; i++) { if (board[i].isRevealed()) { count++; } } return (count == board.length); // 当所有牌都被揭示时，游戏结束 } public String toString() { String text = ""; for (int i = 0; i < board.length; i++) { if (board[i].isRevealed()) { text += ("[" + board[i].getTop() + "] "); } else { text += ("[ ] "); } } text += ('n'); for (int i = 0; i < board.length; i++) { if (board[i].isRevealed()) { text += ("[" + board[i].getBottom() + "] "); } else { text += ("[ ] "); } } return text; } }
6. 总结
通过本次教程，我们深入理解了在Java中进行对象比较和状态管理的重要性。关键点包括：
- 正确覆写 equals() 和 hashCode()： 这是实现基于对象内容比较的基础。务必记住，当覆写 equals() 时，必须同时覆写 hashCode()，以确保程序行为的正确性和一致性，尤其是在使用集合类时。
- 及时更新对象状态： 游戏逻辑中，当满足特定条件时，必须显式地更新相关对象的内部状态（例如通过调用 setRevealed(true)）。这是确保游戏流程正确推进和结束条件能够被正确判断的关键。
遵循这些原则，开发者可以构建出功能更健壮、逻辑更清晰的面向对象程序，特别是在游戏开发等需要精细状态管理和对象比较的场景中。
