Java记忆游戏：深入理解对象相等性与游戏状态管理

public boolean equals(Domino other) { // 错误的覆写方式
    if (top == bottom) // 错误：只检查自身是否为双面牌
        return true;
    return false;
}

@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
public int hashCode() {
    int hash = 7; // 任意一个非零常数
    hash = 59 * hash + this.getTop(); // 将属性值纳入哈希计算
    hash = 59 * hash + this.getBottom();
    return hash;
}

public boolean guess(int i, int k) {
    if(board[i] == board[k]) { // 错误：使用 == 比较对象引用
        return true;
    }
    return false;
}

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;
}

public boolean isRevealed() {
    if (revealed)
        return true;
    return false;
}

public boolean isRevealed() {
    return revealed;
}

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;
    }
}

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;
    }
}