Java多米诺记忆游戏逻辑修复与对象比较深度解析

本教程旨在解决Java多米诺记忆游戏中常见的逻辑问题，包括多米诺牌无法正确显示为已揭示状态以及游戏无法正常结束。核心解决方案涉及正确覆盖Java对象的equals()和hashCode()方法以实现值比较，并确保在猜对时调用setRevealed()方法更新多米诺牌的状态。通过这些改进，游戏将能够正确识别匹配，并根据牌面状态判断游戏胜利条件。

1. 问题分析

在开发基于java的多米诺记忆游戏时，开发者可能遇到以下两个主要问题：

多米诺牌匹配后未能保持揭示状态： 即使玩家猜对了匹配的多米诺牌，这些牌在后续的游戏界面刷新中仍然显示为未揭示状态。游戏无法正常结束： 即使所有多米诺牌都被正确匹配并理应揭示，游戏也未能检测到胜利条件并终止。

这些问题的根源主要在于Java对象比较的误用以及对象状态管理的不完善。

1.1 对象比较的误区：== 与 equals()

在Java中，==运算符用于比较基本数据类型的值，以及对象的引用地址。当用于对象时，board[i] == board[k]实际上是检查board[i]和board[k]这两个引用是否指向内存中的同一个对象实例。然而，在记忆游戏中，我们希望比较的是两个多米诺牌的“值”是否相等（即它们的顶部和底部数字是否相同），而不是它们是否是同一个对象。

原始的Domino类中虽然有一个equals(Domino other)方法，但其实现存在逻辑错误（if (top == bottom) return true;），并且在MemoryLane类的guess方法中，并没有调用这个自定义的equals方法，而是使用了board[i] == board[k]进行引用比较。这导致即使两个多米诺牌的值相同，它们也不会被认为是匹配的，因为它们是不同的对象实例。

1.2 状态管理缺失：setRevealed() 未被调用

Domino类中定义了revealed布尔变量和setRevealed(boolean revealed)方法，旨在标记多米诺牌是否已揭示。然而，在MemoryLane的guess方法中，即使判断为匹配（尽管判断方式有误），也没有调用setRevealed(true)来更新相应多米诺牌的revealed状态。这意味着多米诺牌的揭示状态从未被实际改变，导致它们在toString()方法渲染时总是显示为未揭示。

立即学习“Java免费学习笔记（深入）”；

1.3 游戏结束条件判断失误

MemoryLane类中的gameOver()方法通过遍历board数组，检查所有多米诺牌的isRevealed()状态来判断游戏是否结束。由于setRevealed()方法从未被调用，isRevealed()始终返回false，导致count变量永远不会达到board.length，因此游戏永远不会结束。

2. 解决方案与实现

要解决上述问题，我们需要对Domino类和MemoryLane类进行关键性的修改。

2.1 正确覆盖 Domino 类的 equals() 和 hashCode() 方法

在Java中，当需要比较两个对象的逻辑相等性（即它们的值是否相等，而非引用地址）时，必须覆盖Object类提供的equals()方法。同时，根据Java规范，如果覆盖了equals()方法，也必须覆盖hashCode()方法，以维护equals()和hashCode()之间的契约。

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() {        // 简化后的isRevealed方法，直接返回revealed状态        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;        }        // 检查obj是否为null或类型不匹配        if (!(obj instanceof Domino)) {            return false;        }        // 将obj强制转换为Domino类型        final Domino other = (Domino) obj;        // 比较top和bottom属性是否相等        if (this.getTop() != other.getTop()) {            return false;        }        if (this.getBottom() != other.getBottom()) {            return false;        }        return true;    }}

equals() 和 hashCode() 契约的重要性：

如果两个对象根据equals(Object)方法是相等的，那么调用这两个对象中任意一个的hashCode()方法都必须产生同样的整数结果。如果两个对象根据equals(Object)方法是不相等的，那么调用这两个对象中任意一个的hashCode()方法不要求产生不同的整数结果。但是，为不相等的对象生成不同的哈希码可以提高哈希表（如HashMap、HashSet）的性能。

2.2 更新 MemoryLane 类的 guess() 方法

现在，Domino对象可以正确地进行值比较了。接下来，我们需要修改MemoryLane类中的guess()方法，使其使用Domino类中新覆盖的equals()方法进行比较，并在匹配成功时更新多米诺牌的揭示状态。

MemoryLane 类修改：

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  0; i--) {            index = random.nextInt(i + 1);            if (index != i) {                Domino temp = board[index];                board[index] = board[i];                board[i] = temp;            }        }    }    public boolean guess(int i, int k) {        // 使用Domino的equals方法进行值比较        if (board[i].equals(board[k])) {            // 如果匹配成功，设置这两张牌为已揭示            board[i].setRevealed(true);            board[k].setRevealed(true);            return true;        }        return false;    }    public String peek(int a, int b) {        String text = new String();        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 = new String();        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;    }}

3. 完整示例代码

为了提供一个可运行的完整示例，我们将Domino和MemoryLane类作为内部类或单独文件进行组织。这里提供一个将它们作为内部类包含在Main类中的示例，以方便测试。

import java.util.Random;import java.util.Scanner;public class Main {    public static void main(String[] args) {        new Main().runGame();    }    public void runGame() {        String message = "Welcome to Memory Lane!" + "n"                + "Choose two indexes to reveal the corresponding dominoes." + "n"                + "If the dominoes match, they stay revealed." + "n"                + "Reveal all the dominoes to win the game!" + "n";        System.out.println(message);        Scanner input = new Scanner(System.in);        // 使用max=2，生成(2*2)+2 = 6张多米诺牌        MemoryLane game = new MemoryLane(2);        long start = System.currentTimeMillis();        while (!game.gameOver()) {            // 打印当前游戏板状态            System.out.println(game);            System.out.print("First:  ");            int first = input.nextInt();            System.out.print("Second: ");            int second = input.nextInt();            // 检查用户输入的索引是否有效            if (first = game.board.length || second = game.board.length) {                System.out.println("Invalid index. Please enter numbers between 0 and " + (game.board.length - 1));                continue; // 跳过本次循环，重新输入            }            // 尝试猜测            boolean isMatch = game.guess(first, second);            System.out.println(game.peek(first, second) + "n"); // 显示选择的牌            if (isMatch) {                System.out.println("It's a match! These dominoes will stay revealed.");            } else {                System.out.println("No match. Try again!");                // 对于不匹配的情况，需要将牌重新隐藏。                // 原始问题中没有提及此需求，但通常记忆游戏会在不匹配时隐藏牌。                // 这里为了保持与原代码逻辑一致，不自动隐藏。                // 如果需要隐藏，可以在这里添加 board[i].setRevealed(false); board[k].setRevealed(false);                // 但这需要修改peek方法，使其临时揭示，然后根据是否匹配决定是否保持揭示。                // 鉴于驱动程序不允许修改，我们保持现有行为。            }        }        long stop = System.currentTimeMillis();        long elapsed = (stop - start) / 1000;        System.out.println(game); // 游戏结束时显示最终状态        System.out.println("nYou win!");        System.out.println("Total time: " + elapsed + "s");        input.close();    }    // Domino Class    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;            // 确保比较的是多米诺牌的top和bottom值            if (this.getTop() != other.getTop()) {                return false;            }            if (this.getBottom() != other.getBottom()) {                return false;            }            return true;        }    }    // MemoryLane Class    public class MemoryLane {        private Domino[] board;        public MemoryLane(int max) {            board = new Domino[(max * max) + max]; // 例如max=2时，数组大小为6            int i = 0;            // 生成多米诺牌对            for (int top = 1; top <= max; top++) {                for (int bot = 1; bot <= max; bot++) {                    if (top  0; i--) {                index = random.nextInt(i + 1);                // 交换元素                Domino temp = board[index];                board[index] = board[i];                board[i] = temp;            }        }        public boolean guess(int i, int k) {            // 确保索引有效且不相同            if (i == k || i = board.length || k = board.length) {                return false; // 无效猜测            }            // 核心修复：使用equals方法比较对象内容            if (board[i].equals(board[k])) {                // 如果匹配，则设置多米诺牌为已揭示状态                board[i].setRevealed(true);                board[k].setRevealed(true);                return true;            }            return false;        }        public String peek(int a, int b) {            // 临时显示所选牌面，无论是否匹配            String text = "";            if (a >= 0 && a = 0 && b < board.length) {                text += ("[" + board[a].getTop() + "] [" + board[b].getTop() + "]n");                text += ("[" + board[a].getBottom() + "] [" + board[b].getBottom() + "]n");            } else {                text = "Invalid peek indices.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 debug() {            String text = "";            for (int i = 0; i < board.length; i++) {                text += ("[" + board[i].getTop() + "," + board[i].getBottom() + "] ");            }            text += ('n');            return text;        }        @Override        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;        }    }}

4. 注意事项与总结

equals() 和 hashCode() 的重要性： 对于自定义类，当需要比较对象的逻辑内容而非内存地址时，务必正确覆盖equals()方法。同时，为了确保在哈希集合（如HashSet、HashMap的键）中正常工作，必须同时覆盖hashCode()方法，并遵循其契约。这是Java面向对象编程中的一个基本而重要的原则。对象状态管理： 明确对象应如何响应外部操作并改变自身状态。在本例中，当多米诺牌被成功匹配时，其revealed状态必须被显式更新，才能反映在游戏界面上并影响游戏结束条件。游戏逻辑的完整性： 确保游戏的胜利或失败条件能够基于正确的状态进行判断。当所有关键状态（如revealed）都得到正确维护时，gameOver()等方法才能准确地反映游戏进程。代码可读性与维护性： 良好的命名、清晰的逻辑和适当的注释有助于提高代码的可读性和未来的维护性。

通过以上修改，多米诺记忆游戏将能够正确地识别匹配、保持揭示状态，并最终在所有牌被揭示后正常结束。这不仅解决了功能上的问题，也强化了对Java中对象比较和状态管理核心概念的理解。

以上就是Java多米诺记忆游戏逻辑修复与对象比较深度解析的详细内容，更多请关注创想鸟其它相关文章！