Java记忆游戏：对象比较与状态控制解析

各位小伙伴们，大家好呀！看看今天我又给各位带来了什么文章？本文标题是《Java记忆游戏：对象相等与状态管理解析》，很明显是关于文章的文章哈哈哈，其中内容主要会涉及到等等，如果能帮到你，觉得很不错的话，欢迎各位多多点评和分享！

本文深入探讨了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 属性。

@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 <= bottom，我们只需要比较 top 和 bottom 的值即可。

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)）。这是确保游戏流程正确推进和结束条件能够被正确判断的关键。

遵循这些原则，开发者可以构建出功能更健壮、逻辑更清晰的面向对象程序，特别是在游戏开发等需要精细状态管理和对象比较的场景中。

本篇关于《Java记忆游戏：对象比较与状态控制解析》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！