Java+Swing数独小游戏课程设计：回溯算法与界面开发实战解析

简介：基于Java与Swing界面库编写的数独小游戏，是一份适合Java课程设计场景的完整源码与资源文件包，面向正在学习Java图形界面编程、需要完成小游戏类课设作业的高校学生，也可作为Swing布局管理、事件监听与基础算法实现的练手样例。压缩包共包含21个文件，其中6个Java源文件承担游戏核心逻辑与界面交互，5个XML配置用于IDE工程管理，3个PNG图片及ICO图标等作为界面与启动资源，整体仅81KB，轻量小巧，支持在MyEclipse或IDEA中直接导入运行。目前已有1004人学习下载，内置数独棋盘生成、玩家填入校验、难度选择等常见功能，工程文件与资源配置完整，能够帮助读者快速梳理Swing桌面程序的组织方式，也为后续二次开发或课程设计答辩提供了扎实基础。总体而言，这份资源覆盖了从界面绘制到业务逻辑的完整流程，适合作为Java课设或自学项目的起步模板。

1. 数独小游戏用 Java+Swing 做课程设计：一个能拿高分又能写进简历的选题

每到期末，就会看到一批同学在 Java 课程设计选题上纠结。管理系统太老套，贪吃蛇又撞车，而“基于 Java+Swing 构建的数独小游戏”这个题目，属于那种看似普通、但上限很高的选择：它同时覆盖了 Swing 界面编程、事件监听、回溯算法、随机数生成、文件读写和打包发布这几个课程核心考点。评阅老师一眼能看出工作量，面试官也能从里面问出算法和设计问题。源码和资源文件齐全的话，这份作业还能直接扩展成毕设或作品集项目。这篇文章就按“从零到能交作业”的思路，把完整的设计方案、核心代码、参数调法和踩坑记录逐段拆开讲。

数独这个游戏本身规则简单：9×9 盘面，每行、每列、每个 3×3 宫格内填入 1 到 9，且不能重复。但“让程序自己生成有唯一解的题目”和“让玩家操作时给出智能反馈”这两件事，反而是整个项目的难点所在。好处是，这两个难点恰好就是 Java 课程设计的评分点：算法能力、界面交互、异常处理、资源组织方式，每一项都能从代码里翻出来。

2. 为什么选 Swing 而不是 JavaFX：课程设计的技术选型和项目结构

2.1 用 Swing 当界面的三个现实理由

常见做法里，Java 桌面程序现在有两个主流方案：Swing 和 JavaFX。不少同学一上来就想用 JavaFX，因为它看起来更现代、样式更炫。但这里有个容易被忽略的现实问题：这是一门 Java 课程设计作业，评分标准围绕的是 Java 语法、面向对象思想、常用 API 和数据结构的运用，不是 UI 美观度。Swing 是 JDK 自带的库，不需要额外配置 Scene Builder、不需要单独安装运行环境，只要装了 JDK 就能直接编译运行。

从写作和答辩角度看，Swing 也更容易“讲清楚”。Swing 的事件监听机制使用的是标准的 ActionListener 和 MouseListener 接口，配合匿名内部类或 Lambda 表达式，正好可以展示 Java 核心语法中的多态、匿名类这些高频考点。而 JavaFX 的属性和绑定机制、CSS 样式分离等概念，在课程设计答辩时反而容易把老师绕进复杂度里。

最后一个理由是兼容性。Swing 从 JDK 1.2 开始就存在，到 JDK 8 之后也一直稳定维护，不会因为换了一台 JDK 版本较新的机器就出现运行时异常。JavaFX 在 JDK 8 之后从 JDK 中抽离，需要单独引入，这会让“拷贝到哪都能跑”的作业验收环节多出一层不必要的风险。所以我的一般做法是：只要课程设计没有强制要求用 JavaFX，就踏踏实实用 Swing。

2.2 把项目分成三层：界面、逻辑、数据

整个项目的目录结构，我会建议学生按下图这样组织，这本身就体现了一个很重要的设计思想——界面与业务逻辑分离（MVC 的轻量实现）：

src/ com/course/sudoku/ model/ # 数据模型与核心算法 SudokuGenerator.java # 生成完整数独盘面 SudokuSolver.java # 求解器/唯一解判断 SudokuChecker.java # 行/列/宫合法性校验 view/ # Swing 界面 MainFrame.java # 主窗口 JFrame SudokuPanel.java # 9x9 宫格绘制 JPanel CellButton.java # 单个格子的 JButton 扩展 controller/ # 事件绑定与业务调度 GameController.java # 难度配置、计时、状态管理 resources/ levels/ # 题库文件（每行一个题目字符串） sound/ # 选填：按钮音效 images/ # 选填：图标

界面层只负责“点击某个格子、把数字画上去、弹出提示框”，算法层只负责“生成题目、判断输赢、给出候选数”。这样拆分后，最直接的好处是答辩时你可以指着GameController说“游戏流程都在这里”，也可以指着SudokuGenerator说“算法和界面完全解耦”。这在评分标准里通常对应模块化设计的加分项。

2.3 用接口约束算法层，给后面扩展留空间

我一般会在model层定义一个生成器接口，而不是直接写死一个工具类。原因很简单：数独生成算法有回溯法、随机填充法、从题库读题等多种实现，课程设计阶段用回溯法，但如果想要扩展“从资源文件读取题库”的功能，接口就能在不改调用方的前提下切换实现。

public interface PuzzleProvider { int[][] generate(int difficulty); // 返回 9x9 盘面，0 表示空格 boolean isValid(int[][] board); // 校验盘面是否合法 }

定义接口之后，写一个基于回溯法的SudokuGenerator实现类。这样你在 controller 里不用关心具体生成算法，只需要PuzzleProvider provider = new SudokuGenerator();，将来换成“提示难度选择”时，逻辑链路不需要大改，这是边界清晰带来的直接收益。难度参数difficulty在这里用 1 到 3 表示简单、中等、困难，实现的时候会把不同数量的空格写入盘面。

3. 核心算法层：用回溯法生成数独题目并保证唯一解

3.1 从空白盘面到完整盘面：求解器的写法是先决条件

在做“出题”之前，必须先做一个“求解器”。常见的思路是：先用回溯法生成一个完整的 9×9 终盘，然后随机挖掉一定数量的数字，形成题目。而判断挖掉数字后题目是否还有唯一解，同样要依赖回溯法。这两个算法写在一起，就是整个项目的工作量核心。

先看最基本的合法性校验，这是求解器的地基：

public class SudokuValidator { /** * 检查在 board[row][col] 位置填入 value 是否合法 * @param board 当前盘面，0 表示空格 * @param row 行下标 0~8 * @param col 列下标 0~8 * @param value 尝试填入的 1~9 数字 */ public static boolean isSafe(int[][] board, int row, int col, int value) { // 检查行 for (int c = 0; c < 9; c++) { if (board[row][c] == value) { return false; } } // 检查列 for (int r = 0; r < 9; r++) { if (board[r][col] == value) { return false; } } // 检查 3x3 宫格 int boxRow = row / 3 * 3; int boxCol = col / 3 * 3; for (int r = boxRow; r < boxRow + 3; r++) { for (int c = boxCol; c < boxCol + 3; c++) { if (board[r][c] == value) { return false; } } } return true; } }

这个类虽然短，但它是后面所有算法的“地基”。注意/3*3这个写法，它是定位宫格起始坐标的经典做法，例如row = 4时4/3 = 1，乘以 3 后得到3，正是第二宫所在的行起点。

3.2 求解器：在空格处按随机顺序填数

写求解器的关键不在“能不能填出来”，而在“怎么填才既能快又能随机”。生成完整终盘时，如果每次都按 1 到 9 的固定顺序试填，会导致终盘有规律的分布，玩家一眼就能看出模式。所以我一般会用Collections.shuffle打乱数字候选列表。

import java.util.ArrayList; import java.util.List; import java.util.Collections; public class SudokuSolver { /** * 用回溯法求解一个数独盘面 * @param board 9x9 盘面，0 表示待填 * @return 是否有解，有解时 board 被修改为最终结果 */ public static boolean solve(int[][] board) { return solveInternal(board, true); } /** * 带随机打乱的回溯求解, useRandomOrder 为 true 时用于生成终盘 */ private static boolean solveInternal(int[][] board, boolean useRandomOrder) { for (int row = 0; row < 9; row++) { for (int col = 0; col < 9; col++) { if (board[row][col] == 0) { List<Integer> candidates = new ArrayList<>(); for (int v = 1; v <= 9; v++) { candidates.add(v); } if (useRandomOrder) { Collections.shuffle(candidates); } for (int value : candidates) { if (SudokuValidator.isSafe(board, row, col, value)) { board[row][col] = value; if (solveInternal(board, useRandomOrder)) { return true; } board[row][col] = 0; // 回溯撤销 } } return false; // 所有候选都试过仍失败 } } } return true; // 没有空格说明已解完 } }

逻辑说明：这段代码的核心是“尝试-递归-撤销”三步。先找到第一个空格，然后遍历候选数字，能填就递归；如果递归失败就恢复为0，继续试下一个数字。这里的useRandomOrder参数是留给生成完整终盘用的，求解唯一解时用固定顺序反而更快。

参数说明：board是二维int数组，约定0代表空格。这个方法会直接修改传入的数组，也就是说调用方不需要再用返回值接收结果，这样在后续的挖空操作里非常方便。

3.3 挖空与唯一解判定：这块写不好，题目就废了

挖空听起来简单：生成终盘后，随机挑坐标，把值改成0。但这里有个容易被忽略的细节：每次挖空后，必须用求解器验证一次唯一解。如果当前题目已经有多个解了，就要撤销这次挖空，再试其他坐标。

唯一解判定的思路是：继续用回溯法，但找到一个解之后不立即返回，而是继续尝试找第二个解。只要找到两个不同解就停止，说明当前盘面没有唯一解。

public class SudokuGenerator implements PuzzleProvider { @Override public int[][] generate(int difficulty) { // 1. 生成完整终盘 int[][] board = new int[9][9]; SudokuSolver.solve(board); // difficulty: 1 简单挖 35 个, 2 中等挖 45 个, 3 困难挖 55 个 int cellsToRemove = switch (difficulty) { case 1 -> 35; case 2 -> 45; case 3 -> 55; default -> 40; }; // 2. 随机挖空，每挖一次都检查唯一解 Random random = new Random(); int removed = 0; while (removed < cellsToRemove) { int row = random.nextInt(9); int col = random.nextInt(9); if (board[row][col] == 0) { continue; // 已经挖过 } int backup = board[row][col]; board[row][col] = 0; if (!hasUniqueSolution(board)) { board[row][col] = backup; // 挖掉后会多解，回滚 } else { removed++; } } return board; } @Override public boolean isValid(int[][] board) { return hasUniqueSolution(board); } /** * 判断盘面是否有唯一解，用"找两个解"的方式提高效率 */ private boolean hasUniqueSolution(int[][] board) { return countSolutions(board, 0) == 1; } private int countSolutions(int[][] board, int count) { if (count >= 2) { return count; // 已经发现两个解，提前返回 } for (int row = 0; row < 9; row++) { for (int col = 0; col < 9; col++) { if (board[row][col] == 0) { for (int value = 1; value <= 9; value++) { if (SudokuValidator.isSafe(board, row, col, value)) { board[row][col] = value; count = countSolutions(board, count); board[row][col] = 0; } } return count; } } } return count + 1; } }

逻辑说明：countSolutions在找到一个完整解之后仍然不退出，而是继续回溯尝试其他分支，直到搜寻完整个解空间。同时在递归入口做剪枝——count >= 2直接返回，避免无谓搜索。

参数说明：cellsToRemove的取值决定了难度。35 个空格大约需要两分钟完成，45 个空格开始需要一定的推理技巧，55 个空格对新手已经很吃力。我实际测试下来，挖到 58 个左右时唯一解校验时间会明显变长，而且经常要回滚，这是正常现象，不建议为了“显得难”而盲目增加挖空数量。

这里有一个血泪经验：挖空数量不是越多越好。有些同学为了体现所谓“高难度”，把空格调到 60 个以上，结果生成题目时频繁触发回滚，甚至可能找不到合法解。课程设计的作业维度上，45-50 个空格已经足够展示算法能力，还不会让玩家劝退。

4. Swing 界面层：把 9×9 网格画出来并响应操作

4.1 用 JButton 网格实现交互盘面：显示、编辑、状态标记

数独界面的主体是一个 9×9 的按钮矩阵。每个格子用一个自定义的JButton或JLabel承载，区别在于 JButton 能自然处理鼠标点击事件，但不便于“选中高亮”后的二次编辑。这里有个常见做法是：点击格子弹出数字选择框（或监听键盘数字键）来填入，而不是直接让按钮变成输入框。

import javax.swing.*; import java.awt.*; public class SudokuPanel extends JPanel { private JButton[][] cells = new JButton[9][9]; private int selectedRow = -1; private int selectedCol = -1; private int[][] puzzle; // 当前题目副本，0 表示空格 private int[][] solution; // 标准答案，用于输赢判断 public SudokuPanel(int[][] puzzle, int[][] solution) { this.puzzle = puzzle; this.solution = solution; setLayout(new GridLayout(9, 9, 2, 2)); for (int row = 0; row < 9; row++) { for (int col = 0; col < 9; col++) { JButton btn = new JButton(); btn.setFont(new Font("Dialog", Font.BOLD, 20)); if (puzzle[row][col] != 0) { btn.setText(String.valueOf(puzzle[row][col])); btn.setEnabled(false); // 题目数字不可编辑 } int r = row; int c = col; btn.addActionListener(e -> selectCell(r, c)); cells[row][col] = btn; add(btn); } } } }

逻辑说明：GridLayout(9, 9, 2, 2)让 81 个按钮紧凑排列，2, 2是水平与垂直间距。题目自带的已填数字直接把按钮置灰禁用，这样就省去了判断“能否编辑”的额外逻辑。点击事件用 Lambda 表达式绑定，这是 Java 8 之后的标准写法，在答辩中也能作为 Java 新特性的加分点。

参数说明：puzzle数组里的非 0 值显示为不可编辑数字，solution数组用于后续的“提示”和“检查答案”功能。注意传进来的数组必须各存一份副本，直接引用同一个数组会让后续“重置游戏”状态混乱。

4.2 选中格子的高亮效果和宫格边框：视觉分层的关键技巧

界面不能只是“能玩”，还得“看得清”。数独最经典的视觉需求是 3×3 宫格边界。直接在GridLayout里没法给每条边设置不同粗细，一般有两种方案：一是给部分按钮设置特殊边框，二是把 9×9 的GridLayout拆成 3×3 的大网格，每个大网格内部放一个 3×3 的小网格。

我一般用第二种，它逻辑上更贴近数独的规则结构：

public class SudokuPanel extends JPanel { public void rebuildUI() { removeAll(); setLayout(new GridLayout(3, 3, 3, 3)); // 大宫格间距，让 3x3 边界显形 for (int boxRow = 0; boxRow < 3; boxRow++) { for (int boxCol = 0; boxCol < 3; boxCol++) { JPanel smallGrid = new JPanel(new GridLayout(3, 3, 1, 1)); smallGrid.setBorder(BorderFactory.createLineBorder(Color.BLACK, 2)); for (int r = 0; r < 3; r++) { for (int c = 0; c < 3; c++) { int row = boxRow * boxRowSize + r; int col = boxCol * boxColSize + c; // 全局坐标换算 smallGrid.add(cells[row][col]); } } add(smallGrid); } } revalidate(); repaint(); } }

逻辑说明：全局坐标row = boxRow * 3 + r是关键换算，boxRow是第几个 3×3 宫格，r是宫格内的行偏移。smallGrid加边框，大网格的GridLayout间距设成3像素，整体看起来就是清晰的粗边框效果。

参数说明：smallGrid.setBorder(...)用的是BorderFactory.createLineBorder(Color.BLACK, 2)，颜色和粗细可以调。如果想进一步做选中高亮，在selectCell方法里遍历所有按钮，把背景色重置，只让当前按钮变成浅蓝色背景即可。这里要注意JButton在部分 LookAndFeel 下会忽略背景色设置，推荐在构造按钮时就调用btn.setBackground(Color.WHITE)先固定颜色模式。

4.3 数字输入交互：框选 + 键盘输入，比 JOptionPane 更顺手

一个容易让玩家烦躁的交互是用模态对话框来填数字。每填一个格子弹一次输入框，玩一局要弹几十次，烦到怀疑人生。我一般实现的方式是：点击格子表示选中，然后直接监听键盘数字键 1-9 输入；按 Delete 或 0 清空当前格子。

btn.addKeyListener(new KeyAdapter() { @Override public void keyPressed(KeyEvent e) { if (selectedRow == -1 || selectedCol == -1) { return; } char keyChar = e.getKeyChar(); if (keyChar >= '1' && keyChar <= '9') { fillNumber(selectedRow, selectedCol, keyChar - '0'); } else if (e.getKeyCode() == KeyEvent.VK_DELETE || e.getKeyCode() == KeyEvent.VK_BACK_SPACE) { fillNumber(selectedRow, selectedCol, 0); } } });

逻辑说明：需要btn.setFocusable(true)让按钮能获得键盘焦点，否则按键事件不会触发。这里有一个小陷阱：如果每个格子按钮都注册了 KeyListener，但当前选中格子和触发按键的格子不一定一致，所以回调里用的不是“事件来源按钮”的坐标，而是selectedRow/selectedCol这两个全局状态。

4.4 主窗口中的组件布局：菜单栏、计时器、状态面板

主窗口MainFrame负责把所有部件拼起来。我常用的布局是：JMenuBar放“新游戏”“检查”“重新开始”等菜单项，窗口中央放 9×9 盘面，底部放一个JLabel做状态提示（显示当前选择的行列、错误次数、计时等）。

public class MainFrame extends JFrame { private SudokuPanel sudokuPanel; private JLabel statusLabel; private Timer timer; private int elapsedSeconds; public MainFrame() { setTitle("Java+Swing 数独小游戏"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setSize(560, 650); setLocationRelativeTo(null); // 窗口居中 statusLabel = new JLabel("点击空格后按 1-9 填入，Delete 清空"); statusLabel.setHorizontalAlignment(SwingConstants.CENTER); initMenuBar(); newGame(2); // 默认中等难度 add(sudokuPanel, BorderLayout.CENTER); add(statusLabel, BorderLayout.SOUTH); } }

逻辑说明：setLocationRelativeTo(null)是让窗口在屏幕中央的标准化写法。newGame(2)会终止旧计时器、生成新题目并刷新盘面。计时器这里用javax.swing.Timer而不是java.util.Timer，因为 Swing Timer 的回调自动跑在事件分发线程 EDT 上，直接调用statusLabel.setText(...)不会产生线程安全问题。

5. 资源文件与完整成品：题库、图标、配置的管理方式

5.1 题库资源文件：把题目存进去而不是每次现生成

每次启动游戏时都用回溯法现场生成题目，设计上没问题，但如果想在答辩时演示“打开某个固定题目给别人展示”，或者在资源文件里准备几套有特色的题目，那么把题目持久化到文件里就是刚需。常见格式是每行一个题目字符串，用 0 表示空格，共 81 个字符，比如：

530070000600195000098000060800060003400803001700020006060000280000419005000080079

读取这个资源的代码要放在启动时加载，并且做字符数量校验：

import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.List; public class LevelFileLoader { public static int[][] loadFromFile(String resourcePath) { List<String> lines = new ArrayList<>(); try (InputStream in = LevelFileLoader.class.getResourceAsStream(resourcePath); BufferedReader reader = new BufferedReader( new InputStreamReader(in, StandardCharsets.UTF_8))) { String line; while ((line = reader.readLine()) != null) { if (line.trim().isEmpty()) { continue; } lines.add(line.trim()); } } catch (Exception e) { throw new IllegalStateException("读取题库失败: " + resourcePath, e); } if (lines.isEmpty()) { throw new IllegalStateException("题库文件为空"); } return parseLine(lines.get(0)); } private static int[][] parseLine(String line) { if (line.length() != 81) { throw new IllegalArgumentException("题目长度必须为 81，实际为 " + line.length()); } int[][] board = new int[9][9]; for (int i = 0; i < 81; i++) { int v = line.charAt(i) - '0'; board[i / 9][i % 9] = v; } return board; } }

逻辑说明：题目字符串的 81 个字符，按行优先顺序写入二维数组。getResourceAsStream读取的是 classpath 下的资源文件，这样把项目打包成 jar 后，题库文件仍然在 jar 包内，不需要额外分发外部文件。charAt(i) - '0'是字符转数字的常用技巧：字符'5'的 ASCII 码值是 53，'0'是 48，两值相减就得到 5。

注意一点：不要把资源目录写成src/resources/xxx.txt再直接用File去读，因为打包成 jar 后File路径不存在。用 classpath 方式是标准做法。

5.2 配置文件的默认值：把难度、音效开关做成可调参数

资源文件里除了题库，还可以放一个简单的配置文件，用于控制游戏默认参数。Swing 项目用Properties类是标准方案，不引入额外依赖：

import java.io.InputStream; import java.util.Properties; public class GameConfig { private Properties props = new Properties(); public GameConfig() { try (InputStream in = getClass().getResourceAsStream("/game.properties")) { if (in != null) { props.load(in); } } catch (Exception e) { System.err.println("配置文件读取失败，使用默认配置"); } } public int getDefaultDifficulty() { return Integer.parseInt(props.getProperty("defaultDifficulty", "2")); } public boolean isSoundEnabled() { return Boolean.parseBoolean(props.getProperty("soundEnabled", "true")); } public int getMaxMistakes() { return Integer.parseInt(props.getProperty("maxMistakes", "3")); } }

参数说明：defaultDifficulty取值 1-3 对应简单、中等、困难。maxMistakes表示允许答错几次，达到上限后触发游戏结束。这里的三个参数都会在GameController中被实际读取并驱动流程。配置文件放在项目根目录的resources/game.properties下，内容形式如下：

defaultDifficulty=2 soundEnabled=false maxMistakes=3

5.3 把运行脚本交给老师：一键启动的三种方式

课程设计提交时，很多人会把代码打包成 jar，但老师在 Windows 上不一定配了 JDK 环境变量。为了让验收环节顺畅，我一般会提供三个入口文件，这里用到的“资源文件”概念就包括了这些辅助脚本：

# run.bat - Windows 一键启动 @echo off java -jar sudoku-game.jar pause

# run.sh - Linux/macOS 启动 #!/bin/bash java -jar sudoku-game.jar

第二种方式是把源码用 IDE（如 IntelliJ IDEA）打开，直接运行MainFrame的 main 方法。第三种是命令行编译运行。如果老师要求“必须是源码能编译”，那么第二种方式最保险。为了这三个方式都成立，注意 main 方法中setVisible(true)放在 Swing EDT 上调用：

public static void main(String[] args) { SwingUtilities.invokeLater(() -> { MainFrame frame = new MainFrame(); frame.setVisible(true); }); }

逻辑说明：invokeLater确保所有界面组件都在事件分发线程中创建，这是一个重要规范。部分机器上，直接在主线程 new JFrame 可能看起来能跑，但在 Java 8 之后的某些版本下会出现间歇性的绘制异常，这是典型的翻车现场。

6. 避坑与常见问题排查：Swing、算法、打包三类问题一次说清

6.1 Swing 界面刷新不了：八成是忘了调用 revalidate 和 repaint

现象：点击“重新开始”后，盘面内容还是旧的，或者出现按钮错位。

原因：改动组件层次（比如removeAll()后重新往面板里加按钮）后，Swing 的布局管理器不会自动重新计算位置，需要手动触发。只调用repaint()只能重绘现状，不能重新布局。

解决：在重新组装完所有组件后，依次调用：

removeAll(); // 重新添加子组件 revalidate(); // 标记容器需要重新布局 repaint(); // 触发重绘

revalidate()告诉布局管理器“组件树变了”，repaint()再让画面实际刷新。两者缺一不可。如果你只调了repaint()，界面几乎必然出现白屏或错位。

6.2 界面卡死：别把生成题目放到 EDT 主线程里

现象：点“新游戏”后窗口直接转圈，几秒后才恢复。

原因：数独生成算法在最坏情况下需要大量回溯，虽然题目规模不大，但如果挖空数量偏多，在 2GHz 左右的老机器上可能要卡 1-2 秒。而事件回调默认跑在 EDT 上，EDT 被阻塞，整个窗口就无法响应重绘和鼠标事件。

解决：把生成题目的逻辑放到 SwingWorker 里，生成完成后再回调设置界面：

new SwingWorker<int[][], Void>() { @Override protected int[][] doInBackground() { SudokuGenerator generator = new SudokuGenerator(); return generator.generate(selectedDifficulty); } @Override protected void done() { try { int[][] puzzle = get(); sudokuPanel.updatePuzzle(puzzle); statusLabel.setText("新游戏已就绪"); } catch (Exception e) { statusLabel.setText("生成失败，请重试"); } } }.execute();

这是我在实际开发中必然使用的一个模式：凡是耗时超过 200ms 的计算，一律包进SwingWorker。数独虽然小，但生成题目的回溯搜索是不确定的，必须做好保护。否则不仅界面卡死，答辩现场还会给老师留下很差的印象。

6.3 输入数字后存在多个解：唯一解校验只在挖空时做了，玩家填写时没做

现象：游戏过程中出现某一个空格填 3 和填 7 都能通过行/列/宫校验，但最终正确答案只有一个；玩家填了另一个“局部合法”的数字，程序没提示错误。

原因：初始盘面生成时确实保证唯一解，但玩家可能在“推理错误”的情况下填入一个恰好满足局部约束但不是最终答案的数字。这种错误在“填错时立即提示”的实现模式下会被漏掉。

解决：在“检查结果”或“填数后”的回调里，不只是校验当前格的三个约束，而是直接比较该格与solution数组的对应值。最佳实践是：如果你要求“错误立即提示”，就用题目对应的标准答案直接比对；如果你希望玩法更硬核，就不提示，只在完成全盘时检查。

private void fillNumber(int row, int col, int value) { if (puzzle[row][col] != 0) { return; // 题目的初始数字不可改 } cells[row][col].setText(value == 0 ? "" : String.valueOf(value)); if (value != 0 && value != solution[row][col]) { mistakes++; if (mistakes >= maxMistakes) { JOptionPane.showMessageDialog(this, "错误次数已达上限，游戏结束"); return; } } if (isBoardFilled()) { JOptionPane.showMessageDialog(this, "恭喜你完成了数独！"); } }

这一条属于典型的“算法没问题、交互有漏洞”的场景。把“局部合法”和“全局正确”混为一谈，是最容易在测试环节被自己漏掉的逻辑。

6.4 打包 jar 后图片加载不出来：别用 File 路径读资源

现象：在 IDE 里运行正常，点java -jar sudoku-game.jar后图标显示不出来，或者题库读取失败报异常。

原因：打包进 jar 的文件不再是磁盘上的独立文件，new File("resources/icon.png")找不到这个路径。

解决：所有资源文件统一用Class.getResourceAsStream("/resources/icon.png")读取。src目录下的资源会被编译进 classpath，配合 jar 内路径即可生效。核心经验是：只要代码里出现.getAbsolutePath()或以.txt、.png结尾的字符串，那你的资源读法很可能不适合打包发布。

6.5 课程设计答辩时被问“重新开始后状态没清干净”

现象：新开一局后，错误计数、计时器、已填格子的颜色还保留着上一局的残留。

原因：newGame()方法里没有完整重置所有控制器状态。特别是javax.swing.Timer，如果不显式stop()，它还会继续跑。

解决：把所有状态归位集中到一个方法里：

private void resetGameState() { elapsedSeconds = 0; mistakes = 0; selectedRow = -1; selectedCol = -1; if (timer != null) { timer.stop(); } timer = new Timer(1000, e -> { elapsedSeconds++; statusLabel.setText("用时: " + elapsedSeconds + " 秒 | 错误: " + mistakes + " 次"); }); timer.start(); }

resetGameState()在newGame()开头调用，保证一盘游戏之间绝不互相污染。这类问题看似小，但在答辩演示中出错最早被老师注意到。

7. 验证与进阶：从“能跑”到“不敢质疑”，再加一点亮点扩展

7.1 三个级别的自测清单

课程设计最怕的是“演示时才发现某些功能坏掉”。我一般会按下面的清单检查一遍，每条都对应真实操作路径：

这 8 条是我常年在用的数独自测清单，基本能覆盖老师可能动手操作的所有路径。

7.2 进阶功能一：候选数提示

给选中格子显示该格可以填入的所有合法数字，这是很多数独玩家的刚需。实现方式不复杂：在选中格子时，遍历 1-9，用SudokuValidator.isSafe(puzzle, row, col, value)过滤出合法值，显示在状态栏或格子右下角。这一功能不用改任何算法层，只在视图层加展示逻辑，但对作品完整度的提升非常明显。

7.3 进阶功能二：错误标记与撤销

给玩家提供“撤销上一步”的后悔药功能，需要维护一个操作栈：

Deque<int[]> undoStack = new ArrayDeque<>(); // 存储 row, col, oldValue public void undo() { if (undoStack.isEmpty()) { return; } int[] record = undoStack.pop(); int row = record[0]; int col = record[1]; int oldValue = record[2]; fillNumber(row, col, oldValue, false); // false 表示不压栈 }

数独游戏里没有“步数限制”的概念，所以用ArrayDeque作为无限栈，能在不引入额外依赖的情况下实现完整的撤销链。

7.4 从源码到可演示的完整产物

源码、资源文件、运行脚本最终组织成一个交付目录，这个结构本身就是在展示工程化能力。Java+Swing 数独小游戏作为课程设计，核心评分点在于算法层是否严谨、界面交互是否顺畅、工程结构是否清晰。我通常建议把第 3 章的“唯一解校验”算法单独拿出来梳理一遍流程，因为这是整个题目最容易被追问深入细节的点。

一个习惯我一直保持到现在：每做完一个功能，就把当时的测试路径和触发条件记录下来，答辩前按记录逐条回归一遍。这个做法帮我避免过太多次“不知道改了什么突然坏了”的尴尬。希望这篇实操记录帮到正好在赶课程设计的你，也祝你把这份作业变成一个经得起追问的作品。

本文还有配套的精品资源，点击获取