java gui 数独

实现数独游戏的 GUI 可以分为以下几个步骤：

1. 创建一个 JFrame 窗口，设置标题、大小和关闭方式。

2. 在窗口中添加一个 JPanel 面板，用于放置游戏区域。

3. 在 JPanel 面板中用 GridLayout 布局管理器创建一个 9×9 的网格，每个网格内放置一个 JTextField 文本框，用于输入数独的数字。

4. 为 JTextField 文本框添加输入限制，只能输入 1~9 的数字或空格。

5. 创建一个 JButton 按钮，用于开始解题。点击按钮后，程序将尝试解出数独的答案，并在界面上显示结果。

6. 实现数独求解算法。可以使用回溯算法、剪枝算法等。

7. 将数独题目显示在界面上，可以将题目存储在一个二维数组中，并将其填充到 JTextField 文本框中。

下面是一个简单的 Java GUI 数独游戏实现：

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class SudokuGUI extends JFrame implements ActionListener {
    private JPanel gamePanel;
    private JTextField[][] cells;
    private JButton solveButton;

    public SudokuGUI() {
        setTitle("Sudoku Game");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(400, 400);

        gamePanel = new JPanel(new GridLayout(9, 9));
        cells = new JTextField[9][9];

        for (int row = 0; row < 9; row++) {
            for (int col = 0; col < 9; col++) {
                JTextField cell = new JTextField(1);
                cell.setHorizontalAlignment(JTextField.CENTER);
                cell.setDocument(new JTextFieldLimit(1)); // 设置输入限制
                cells[row][col] = cell;
                gamePanel.add(cell);
            }
        }

        solveButton = new JButton("Solve");
        solveButton.addActionListener(this);

        add(gamePanel, BorderLayout.CENTER);
        add(solveButton, BorderLayout.SOUTH);

        setVisible(true);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == solveButton) {
            int[][] puzzle = new int[9][9];
            for (int row = 0; row < 9; row++) {
                for (int col = 0; col < 9; col++) {
                    String text = cells[row][col].getText().trim();
                    if (text.isEmpty()) {
                        puzzle[row][col] = 0;
                    } else {
                        puzzle[row][col] = Integer.parseInt(text);
                    }
                }
            }

            if (SudokuSolver.solve(puzzle)) {
                for (int row = 0; row < 9; row++) {
                    for (int col = 0; col < 9; col++) {
                        cells[row][col].setText(Integer.toString(puzzle[row][col]));
                    }
                }
            } else {
                JOptionPane.showMessageDialog(this, "No solution!");
            }
        }
    }

    public static void main(String[] args) {
        new SudokuGUI();
    }
}

class JTextFieldLimit extends PlainDocument {
    private int limit;

    public JTextFieldLimit(int limit) {
        super();
        this.limit = limit;
    }

    public void insertString(int offset, String str, AttributeSet attr) throws BadLocationException {
        if (str == null) {
            return;
        }

        if ((getLength() + str.length()) <= limit) {
            super.insertString(offset, str, attr);
        }
    }
}

class SudokuSolver {
    public static boolean solve(int[][] puzzle) {
        int row = -1;
        int col = -1;
        boolean isEmpty = true;

        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if (puzzle[i][j] == 0) {
                    row = i;
                    col = j;

                    isEmpty = false;
                    break;
                }
            }

            if (!isEmpty) {
                break;
            }
        }

        if (isEmpty) {
            return true;
        }

        for (int num = 1; num <= 9; num++) {
            if (isValid(puzzle, row, col, num)) {
                puzzle[row][col] = num;

                if (solve(puzzle)) {
                    return true;
                } else {
                    puzzle[row][col] = 0;
                }
            }
        }

        return false;
    }

    private static boolean isValid(int[][] puzzle, int row, int col, int num) {
        for (int i = 0; i < 9; i++) {
            if (puzzle[row][i] == num) {
                return false;
            }
            if (puzzle[i][col] == num) {
                return false;
            }
            if (puzzle[3 * (row / 3) + i / 3][3 * (col / 3) + i % 3] == num) {
                return false;
            }
        }

        return true;
    }
}

在这个实现中，我们使用 JTextFieldLimit 类对文本框进行输入限制，只能输入单个数字或空格。SudokuSolver 类实现了数独求解算法，使用回溯算法逐步填充数独的空格，直到找到解或无解。在 actionPerformed 方法中，我们将用户输入的数独题目转换为一个二维数组，调用 SudokuSolver.solve 方法求解数独，并将结果显示在界面上。