feat:上传代码到mfq分支

src/com/student/mathquiz/Main.java

@@ -0,0 +1,137 @@
+package com.student.mathquiz;
+
+import com.student.mathquiz.constant.UserType;
+import com.student.mathquiz.quiz.Quiz;
+import com.student.mathquiz.quiz.QuizService;
+import com.student.mathquiz.user.User;
+import com.student.mathquiz.user.UserFileService;
+import com.student.mathquiz.user.UserService;
+
+import java.util.Scanner;
+
+/**
+ * 主类（修改：测试后端核心逻辑，替换魔法字符串）
+ */
+public class Main {
+    private static final Scanner SCANNER = new Scanner(System.in);
+    private static final UserService USER_SERVICE = new UserFileService();
+    private static final QuizService QUIZ_SERVICE = new QuizService();
+
+    public static void main(String[] args) {
+        System.out.println("=== 小初高数学学习软件（后端测试）===");
+        while (true) {
+            System.out.println("\n1. 注册  2. 登录  3. 退出");
+            System.out.print("请选择操作：");
+            String choice = SCANNER.nextLine();
+
+            switch (choice) {
+                case "1":
+                    testRegister(); // 测试注册
+                    break;
+                case "2":
+                    testLoginAndQuiz(); // 测试登录+生成试卷+答题
+                    break;
+                case "3":
+                    System.out.println("程序退出！");
+                    SCANNER.close();
+                    System.exit(0);
+                default:
+                    System.out.println("请选择1-3！");
+            }
+        }
+    }
+
+    // 测试注册逻辑
+    private static void testRegister() {
+        System.out.println("\n=== 注册 ===");
+        System.out.print("请输入邮箱：");
+        String email = SCANNER.nextLine();
+
+        // 发送验证码
+        USER_SERVICE.sendVerifyCode(email);
+        System.out.print("请输入验证码：");
+        String verifyCode = SCANNER.nextLine();
+
+        // 选择学段
+        System.out.print("请选择学段（小学/初中/高中）：");
+        String typeStr = SCANNER.nextLine();
+        UserType userType = UserType.fromDisplayName(typeStr);
+        if (userType == null) {
+            System.out.println("学段选择错误！");
+            return;
+        }
+
+        // 设置密码
+        System.out.print("请输入密码（6-10位，含大小写+数字）：");
+        String password = SCANNER.nextLine();
+        System.out.print("请再次输入密码：");
+        String confirmPwd = SCANNER.nextLine();
+        if (!password.equals(confirmPwd)) {
+            System.out.println("两次密码不一致！");
+            return;
+        }
+
+        // 执行注册
+        boolean registerSuccess = USER_SERVICE.register(email, verifyCode, password, userType);
+        System.out.println(registerSuccess ? "注册成功！" : "注册失败！");
+    }
+
+    // 测试登录+生成试卷+答题
+    private static void testLoginAndQuiz() {
+        System.out.println("\n=== 登录 ===");
+        System.out.print("请输入邮箱：");
+        String email = SCANNER.nextLine();
+        System.out.print("请输入密码：");
+        String password = SCANNER.nextLine();
+
+        // 执行登录
+        User user = USER_SERVICE.login(email, password);
+        if (user == null) {
+            return; // 登录失败，返回
+        }
+
+        // 生成试卷
+        System.out.print("\n请输入题目数量（10-30）：");
+        int questionCount = Integer.parseInt(SCANNER.nextLine());
+        Quiz quiz;
+        try {
+            quiz = QUIZ_SERVICE.generateQuiz(user, questionCount);
+            System.out.println("试卷生成成功！共" + questionCount + "道题。");
+        } catch (Exception e) {
+            System.out.println("试卷生成失败：" + e.getMessage());
+            return;
+        }
+
+        // 模拟答题
+        System.out.println("\n=== 开始答题 ===");
+        for (int i = 0; i < quiz.getQuestions().size(); i++) {
+            var question = quiz.getQuestions().get(i);
+            System.out.println("\n第" + (i + 1) + "题：" + question.getContent());
+            System.out.println("选项：");
+            for (int j = 0; j < question.getOptions().size(); j++) {
+                System.out.println(j + ". " + question.getOptions().get(j));
+            }
+            System.out.print("请选择选项（0-3）：");
+            int optionIndex = Integer.parseInt(SCANNER.nextLine());
+            // 提交答案
+            QUIZ_SERVICE.submitAnswer(quiz, i, optionIndex);
+        }
+
+        // 计算分数
+        int score = QUIZ_SERVICE.calculateQuizScore(quiz);
+        System.out.println("\n=== 答题结束 ===");
+        System.out.println("你的分数：" + score + "分（百分制）");
+
+        // 测试修改密码
+        System.out.print("\n是否修改密码？（y/n）：");
+        String changePwdChoice = SCANNER.nextLine();
+        if ("y".equalsIgnoreCase(changePwdChoice)) {
+            System.out.print("请输入原密码：");
+            String oldPwd = SCANNER.nextLine();
+            System.out.print("请输入新密码：");
+            String newPwd = SCANNER.nextLine();
+            boolean changeSuccess = USER_SERVICE.changePassword(email, oldPwd, newPwd);
+            System.out.println(changeSuccess ? "密码修改成功！" : "密码修改失败！");
+        }
+    }
+}

src/com/student/mathquiz/account/Account.java

@@ -1,4 +1,4 @@
-package account;
+package com.student.mathquiz.account;
 
 public class Account {
     private String userName;

src/com/student/mathquiz/account/AccountService.java

@@ -1,4 +1,4 @@
-package account;
+package com.student.mathquiz.account;
 
 public interface AccountService {
     Account login(String username, String password);

src/com/student/mathquiz/account/SimpleAccountService.java

@@ -1,4 +1,4 @@
-package account;
+package com.student.mathquiz.account;
 
 import java.util.HashMap;
 import java.util.Map;

src/com/student/mathquiz/constant/Constants.java

@@ -0,0 +1,18 @@
+package com.student.mathquiz.constant;
+
+public class Constants {
+    // 密码规则：6-10位，含大小写字母+数字
+    public static final int PASSWORD_MIN_LENGTH = 6;    // 最小长度
+    public static final int PASSWORD_MAX_LENGTH = 10;   // 最大长度
+    public static final String PASSWORD_REGEX = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).{" + PASSWORD_MIN_LENGTH + "," + PASSWORD_MAX_LENGTH + "}$";
+
+    // 题目数量规则：10-30道
+    public static final int QUESTION_MIN_COUNT = 10;
+    public static final int QUESTION_MAX_COUNT = 30;
+
+    // 用户数据存储路径（JSON文件）
+    public static final String USER_DATA_PATH = "user_data/users.json";
+
+    // 验证码长度（模拟）
+    public static final int VERIFY_CODE_LENGTH = 6;
+}

src/com/student/mathquiz/constant/UserType.java

@@ -0,0 +1,28 @@
+package com.student.mathquiz.constant;
+
+public enum UserType {
+    PRIMARY("小学"),    // 小学
+    JUNIOR("初中"),     // 初中
+    SENIOR("高中");     // 高中
+
+    private final String displayName; // 界面显示名称
+
+    UserType(String displayName) {
+        this.displayName = displayName;
+    }
+
+    // 根据显示名称获取枚举（用于前端交互）
+    public static UserType fromDisplayName(String displayName) {
+        for (UserType type : UserType.values()) {
+            if (type.displayName.equalsIgnoreCase(displayName)) {
+                return type;
+            }
+        }
+        return null;
+    }
+
+    // 获取界面显示名称
+    public String getDisplayName() {
+        return displayName;
+    }
+}

src/com/student/mathquiz/persistence/FileSaver.java

@@ -1,6 +1,6 @@
-package persistence;
+package com.student.mathquiz.persistence;
 
-import question.Question;
+import com.student.mathquiz.question.Question;
 
 import java.io.File;
 import java.io.FileWriter;
@@ -19,7 +19,7 @@ public class FileSaver {
 
         try (FileWriter writer = new FileWriter(new File(dir, filename))) {
             for (int i = 0; i < questions.size(); i++) {
-                writer.write((i + 1) + ". " + questions.get(i).getQuestion() + "\n\n");
+                writer.write((i + 1) + ". " + questions.get(i).getContent() + "\n\n");
             }
         } catch (IOException e) {
             e.printStackTrace();

src/com/student/mathquiz/persistence/JsonUtils.java

@@ -0,0 +1,49 @@
+package com.student.mathquiz.persistence;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import java.io.*;
+import java.lang.reflect.Type;
+
+/**
+ * JSON工具类：处理JSON序列化/反序列化，用于用户数据存储
+ */
+public class JsonUtils {
+    private static final Gson GSON = new GsonBuilder()
+            .setPrettyPrinting() // 格式化输出（便于调试）
+            .create();
+
+    // 从JSON文件读取数据（泛型：支持任意类型，如List<User>）
+    public static <T> T readFromJson(String filePath, Type type) {
+        File file = new File(filePath);
+        if (!file.exists()) {
+            return null; // 文件不存在，返回空
+        }
+
+        try (Reader reader = new FileReader(file)) {
+            return GSON.fromJson(reader, type);
+        } catch (IOException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    // 将数据写入JSON文件（泛型：支持任意类型）
+    public static <T> boolean writeToJson(String filePath, T data) {
+        File file = new File(filePath);
+        // 确保父目录存在
+        File parentDir = file.getParentFile();
+        if (!parentDir.exists()) {
+            parentDir.mkdirs();
+        }
+
+        try (Writer writer = new FileWriter(file)) {
+            GSON.toJson(data, writer);
+            return true; // 写入成功
+        } catch (IOException e) {
+            e.printStackTrace();
+            return false; // 写入失败
+        }
+    }
+}

src/com/student/mathquiz/persistence/QuestionChecker.java

@@ -1,4 +1,4 @@
-package persistence;
+package com.student.mathquiz.persistence;
 
 import java.io.File;
 import java.io.FileNotFoundException;

src/com/student/mathquiz/question/HighQuestionGenerator.java

@@ -0,0 +1,95 @@
+package com.student.mathquiz.question;
+
+import java.util.*;
+
+/**
+ * 高中题目生成器
+ * 包含：
+ * - 三角函数（sin/cos/tan）特殊角运算
+ * - 二次根式运算
+ * - 分数运算
+ */
+public class HighQuestionGenerator implements QuestionGenerator {
+
+    private static final Random RANDOM = new Random();
+    private static final String[] TRIG_FUNCTIONS = {"sin", "cos", "tan"};
+    private static final Map<String, String> TRIG_VALUES = new HashMap<>();
+
+    static {
+        // 特殊角三角函数值（简化版）
+        TRIG_VALUES.put("sin30", "1/2");
+        TRIG_VALUES.put("sin45", "√2/2");
+        TRIG_VALUES.put("sin60", "√3/2");
+        TRIG_VALUES.put("cos30", "√3/2");
+        TRIG_VALUES.put("cos45", "√2/2");
+        TRIG_VALUES.put("cos60", "1/2");
+        TRIG_VALUES.put("tan30", "√3/3");
+        TRIG_VALUES.put("tan45", "1");
+        TRIG_VALUES.put("tan60", "√3");
+    }
+
+    @Override
+    public Question generateQuestion() {
+        // 随机生成三角函数题
+        return generateTrigQuestion();
+    }
+
+    /**
+     * 生成三角函数题目
+     */
+    private Question generateTrigQuestion() {
+        String func = TRIG_FUNCTIONS[RANDOM.nextInt(TRIG_FUNCTIONS.length)];
+        String[] angles = {"30", "45", "60"};
+        String angle = angles[RANDOM.nextInt(angles.length)];
+
+        String content = func + "(" + angle + "°) = ?";
+        String correctAnswer = TRIG_VALUES.get(func + angle);
+
+        List<String> options = generateOptions(correctAnswer);
+        int correctIndex = shuffleOptions(options, correctAnswer);
+
+        return new Question(content, correctAnswer, options, correctIndex);
+    }
+
+    /**
+     * 生成选项（1个正确 + 3个干扰项）
+     */
+    private List<String> generateOptions(String correctAnswer) {
+        List<String> options = new ArrayList<>();
+        options.add(correctAnswer);
+
+        // 从TRIG_VALUES中随机取干扰项
+        List<String> allValues = new ArrayList<>(TRIG_VALUES.values());
+        Collections.shuffle(allValues);
+
+        for (String val : allValues) {
+            if (!options.contains(val)) {
+                options.add(val);
+            }
+            if (options.size() >= 4) break;
+        }
+
+        return options;
+    }
+
+    /**
+     * 打乱选项顺序，并返回正确答案索引
+     */
+    private int shuffleOptions(List<String> options, String correctAnswer) {
+        int correctIndex = options.indexOf(correctAnswer);
+        Collections.shuffle(options);
+        return options.indexOf(correctAnswer);
+    }
+
+    // 测试
+    public static void main(String[] args) {
+        QuestionGenerator generator = new HighQuestionGenerator();
+        for (int i = 0; i < 5; i++) {
+            Question q = generator.generateQuestion();
+            System.out.println("题干: " + q.getContent());
+            System.out.println("选项: " + q.getOptions());
+            System.out.println("正确答案索引: " + q.getCorrectAnswerIndex());
+            System.out.println("正确答案: " + q.getCorrectAnswer() + "\n");
+        }
+    }
+}

src/com/student/mathquiz/question/MiddleQuestionGenerator.java

@@ -0,0 +1,148 @@
+package com.student.mathquiz.question;
+
+import com.student.mathquiz.constant.UserType;
+
+import java.util.*;
+
+/**
+ * 初中题目生成器
+ * 修正：强制生成含平方（^2）或根号（sqrt）的题目，符合初中题难度要求
+ */
+public class MiddleQuestionGenerator implements QuestionGenerator {
+
+    private static final Random RANDOM = new Random();
+    private static final char[] OPERATORS = {'+', '-', '*', '/'};
+    private static final String[] SPECIAL_OPS = {"^2", "sqrt"}; // 平方、根号（初中题必须包含）
+
+    @Override
+    public Question generateQuestion() {
+        // 关键修改：删除随机分支，强制生成含特殊运算（平方/根号）的题目
+        // 不再生成普通四则运算题，确保符合初中题要求
+        return generateSpecialQuestion();
+    }
+
+    /**
+     * 生成带平方或根号的题目（初中题核心逻辑）
+     */
+    private Question generateSpecialQuestion() {
+        // 随机选择“平方”或“根号”
+        String specialOp = SPECIAL_OPS[RANDOM.nextInt(SPECIAL_OPS.length)];
+
+        if ("^2".equals(specialOp)) {
+            // 生成平方题：如“5^2 + 3 = ?”（结合四则运算，增加难度）
+            int num1 = RANDOM.nextInt(20) + 1; // 1~20（平方后结果不会太大）
+            int num2 = RANDOM.nextInt(10) + 1; // 1~10（参与四则运算的数）
+            char op = OPERATORS[RANDOM.nextInt(OPERATORS.length)];
+
+            // 处理除法（确保整除）
+            if (op == '/') {
+                num2 = RANDOM.nextInt(5) + 1; // 除数1~5
+                num1 = num2 * (RANDOM.nextInt(10) + 1); // 被除数 = 除数 × 倍数
+            }
+
+            // 题干：如“5^2 + 3 = ?”
+            String content = num1 + "^2 " + op + " " + num2 + " = ?";
+            // 计算正确答案：先算平方，再算四则运算
+            int squareResult = num1 * num1;
+            int correctNum = calculateNormalAnswer(squareResult, num2, op);
+            String correctAnswer = String.valueOf(correctNum);
+
+            List<String> options = generateOptions(correctAnswer);
+            int correctIndex = shuffleOptions(options, correctAnswer);
+            return new Question(content, correctAnswer, options, correctIndex);
+
+        } else { // sqrt（根号）
+            // 生成根号题：如“sqrt(25) - 2 = ?”（确保根号结果为整数）
+            int num1 = (int) Math.pow(RANDOM.nextInt(10) + 1, 2); // 1~10的平方（如25=5²）
+            int num2 = RANDOM.nextInt(10) + 1; // 1~10（参与四则运算的数）
+            char op = OPERATORS[RANDOM.nextInt(OPERATORS.length)];
+
+            // 处理除法（确保整除）
+            if (op == '/') {
+                int sqrtResult = (int) Math.sqrt(num1);
+                num2 = RANDOM.nextInt(5) + 1; // 除数1~5
+                // 调整根号内的数，确保根号结果 ÷ 除数 为整数
+                num1 = (num2 * (RANDOM.nextInt(5) + 1)) * (num2 * (RANDOM.nextInt(5) + 1));
+            }
+
+            // 题干：如“sqrt(25) - 2 = ?”
+            String content = "sqrt(" + num1 + ") " + op + " " + num2 + " = ?";
+            // 计算正确答案：先算根号，再算四则运算
+            int sqrtResult = (int) Math.sqrt(num1);
+            int correctNum = calculateNormalAnswer(sqrtResult, num2, op);
+            String correctAnswer = String.valueOf(correctNum);
+
+            List<String> options = generateOptions(correctAnswer);
+            int correctIndex = shuffleOptions(options, correctAnswer);
+            return new Question(content, correctAnswer, options, correctIndex);
+        }
+    }
+
+    /**
+     * 计算普通四则运算答案（辅助方法）
+     */
+    private int calculateNormalAnswer(int num1, int num2, char op) {
+        switch (op) {
+            case '+': return num1 + num2;
+            case '-': return num1 - num2;
+            case '*': return num1 * num2;
+            case '/': return num1 / num2; // 已确保整除
+            default: return 0;
+        }
+    }
+
+    /**
+     * 生成选项（1个正确 + 3个干扰项，复用优化后的逻辑）
+     */
+    private List<String> generateOptions(String correctAnswer) {
+        List<String> options = new ArrayList<>();
+        options.add(correctAnswer);
+        int correctNum = Integer.parseInt(correctAnswer);
+
+        // 增加最大尝试次数，避免死循环
+        int maxTries = 100;
+        int tries = 0;
+
+        while (options.size() < 4 && tries < maxTries) {
+            tries++;
+            int offset = RANDOM.nextInt(20) + 1; // 扩大偏移量，减少重复
+            int wrongNum = RANDOM.nextBoolean() ? correctNum + offset : correctNum - offset;
+
+            if (wrongNum <= 0) continue; // 避免负数
+            String wrongAnswer = String.valueOf(wrongNum);
+            if (!options.contains(wrongAnswer)) {
+                options.add(wrongAnswer);
+            }
+        }
+
+        // 兜底：若尝试多次仍不够，强制补充不重复的数
+        while (options.size() < 4) {
+            int maxNum = options.stream()
+                    .mapToInt(Integer::parseInt)
+                    .max()
+                    .orElse(correctNum);
+            options.add(String.valueOf(maxNum + 1));
+        }
+
+        return options;
+    }
+
+    /**
+     * 打乱选项顺序（复用逻辑）
+     */
+    private int shuffleOptions(List<String> options, String correctAnswer) {
+        int correctIndex = options.indexOf(correctAnswer);
+        Collections.shuffle(options);
+        return options.indexOf(correctAnswer);
+    }
+
+    // 测试：验证初中题是否都含平方/根号
+    public static void main(String[] args) {
+        QuestionGenerator generator = new MiddleQuestionGenerator();
+        for (int i = 0; i < 5; i++) {
+            Question q = generator.generateQuestion();
+            System.out.println("第" + (i+1) + "题：" + q.getContent());
+            System.out.println("是否含平方/根号：" + (q.getContent().contains("^2") || q.getContent().contains("sqrt")));
+        }
+    }
+}

src/com/student/mathquiz/question/PrimaryQuestionGenerator.java

@@ -0,0 +1,159 @@
+package com.student.mathquiz.question;
+
+import com.student.mathquiz.constant.UserType;
+
+import java.util.*;
+
+/**
+ * 小学题目生成器（修改：生成选择题，含4个选项+打乱顺序）
+ */
+public class PrimaryQuestionGenerator implements QuestionGenerator {
+    private static final Random RANDOM = new Random();
+    private static final char[] OPERATORS = {'+', '-', '*', '/'}; // 小学支持的运算符
+
+    @Override
+    public Question generateQuestion() {
+        // 1. 生成基础四则运算题干（2-3个操作数，避免过于复杂）
+        int operandCount = RANDOM.nextInt(2) + 2; // 2或3个操作数
+        List<Integer> operands = new ArrayList<>();
+        List<Character> ops = new ArrayList<>();
+
+        // 生成操作数（1-100的整数）
+        for (int i = 0; i < operandCount; i++) {
+            operands.add(RANDOM.nextInt(100) + 1);
+        }
+
+        // 生成运算符
+        for (int i = 0; i < operandCount - 1; i++) {
+            ops.add(OPERATORS[RANDOM.nextInt(OPERATORS.length)]);
+        }
+
+        // 2. 处理除法：确保能整除（小学需求）
+        handleDivision(operands, ops);
+
+        // 3. 构建题干字符串（如：3 + 5 × 2）
+        StringBuilder contentSb = new StringBuilder();
+        for (int i = 0; i < operandCount; i++) {
+            contentSb.append(operands.get(i));
+            if (i < ops.size()) {
+                contentSb.append(" ").append(ops.get(i)).append(" ");
+            }
+        }
+        String content = contentSb.toString() + " = ?"; // 题干末尾加“= ?”
+
+        // 4. 计算正确答案
+        String correctAnswer = calculateAnswer(operands, ops);
+
+        // 5. 生成选项（1个正确，3个错误）
+        List<String> options = generateOptions(correctAnswer, operandCount, ops);
+
+        // 6. 打乱选项顺序，并记录正确答案索引
+        int correctIndex = shuffleOptions(options, correctAnswer);
+
+        // 7. 返回选择题模型
+        return new Question(content, correctAnswer, options, correctIndex);
+    }
+
+    // ------------------------------ 辅助方法：处理除法（确保整除） ------------------------------
+    private void handleDivision(List<Integer> operands, List<Character> ops) {
+        for (int i = 0; i < ops.size(); i++) {
+            if (ops.get(i) == '/') {
+                int divisor = operands.get(i + 1);
+                if (divisor == 0) {
+                    divisor = 1; // 避免除零
+                    operands.set(i + 1, divisor);
+                }
+                // 重新计算被除数，确保整除（被除数 = 除数 × 随机商（1-10））
+                int quotient = RANDOM.nextInt(10) + 1;
+                int dividend = divisor * quotient;
+                operands.set(i, dividend);
+            }
+        }
+    }
+
+    // ------------------------------ 辅助方法：计算正确答案 ------------------------------
+    private String calculateAnswer(List<Integer> operands, List<Character> ops) {
+        int result = operands.get(0);
+        for (int i = 0; i < ops.size(); i++) {
+            int nextOperand = operands.get(i + 1);
+            switch (ops.get(i)) {
+                case '+':
+                    result += nextOperand;
+                    break;
+                case '-':
+                    result -= nextOperand;
+                    break;
+                case '*':
+                    result *= nextOperand;
+                    break;
+                case '/':
+                    result /= nextOperand; // 已确保整除
+                    break;
+            }
+        }
+        return String.valueOf(result);
+    }
+
+    // ------------------------------ 辅助方法：生成4个选项（1正3错） ------------------------------
+    private List<String> generateOptions(String correctAnswer, int operandCount, List<Character> ops) {
+        List<String> options = new ArrayList<>();
+        // 添加正确答案
+        options.add(correctAnswer);
+        int correctNum = Integer.parseInt(correctAnswer);
+
+        // 关键修改1：增加最大尝试次数（防止死循环），尝试100次还不够就强制生成
+        int maxTries = 100;
+        int tries = 0;
+
+        while (options.size() < 4 && tries < maxTries) {
+            tries++; // 每次循环计数+1
+            // 关键修改2：扩大偏移量范围（1-20），减少重复概率
+            int offset = RANDOM.nextInt(20) + 1;
+            int wrongNum = RANDOM.nextBoolean() ? correctNum + offset : correctNum - offset;
+
+            // 确保错误答案为正数，且不在已有选项中
+            if (wrongNum <= 0) {
+                continue;
+            }
+            String wrongAnswer = String.valueOf(wrongNum);
+            if (!options.contains(wrongAnswer)) {
+                options.add(wrongAnswer);
+            }
+        }
+
+        // 关键修改3：如果尝试100次后仍不够4个选项，强制补充不重复的数（兜底方案）
+        while (options.size() < 4) {
+            // 生成比当前最大数大1的数，确保不重复
+            int maxNum = options.stream()
+                    .mapToInt(Integer::parseInt)
+                    .max()
+                    .orElse(correctNum);
+            String forceWrong = String.valueOf(maxNum + 1);
+            options.add(forceWrong);
+        }
+
+        return options;
+    }
+
+    // ------------------------------ 辅助方法：打乱选项顺序，返回正确答案索引 ------------------------------
+    private int shuffleOptions(List<String> options, String correctAnswer) {
+        // 记录正确答案原始索引
+        int correctIndex = options.indexOf(correctAnswer);
+        // 打乱选项
+        Collections.shuffle(options);
+        // 返回打乱后的正确答案索引
+        return options.indexOf(correctAnswer);
+    }
+
+    // 测试：生成一道小学选择题
+    public static void main(String[] args) {
+        QuestionGenerator generator = new PrimaryQuestionGenerator();
+        for (int i = 0; i < 5; i++) { // 生成5道题，验证是否卡住
+            Question question = generator.generateQuestion();
+            System.out.println("题干：" + question.getContent());
+            System.out.println("选项：" + question.getOptions());
+            System.out.println("正确答案索引：" + question.getCorrectAnswerIndex());
+            System.out.println("正确答案：" + question.getCorrectAnswer());
+        }
+    }
+}

src/com/student/mathquiz/question/Question.java

@@ -0,0 +1,61 @@
+package com.student.mathquiz.question;
+
+import java.util.List;
+
+/**
+ * 问题类（修改：升级为选择题模型，新增选项和正确答案索引）
+ */
+public class Question {
+    private String content;                // 题干（如：3 + 5 = ?）
+    private String correctAnswer;          // 正确答案（原始值，用于计算）
+    private List<String> options;          // 选项列表（4个选项：1正3错）
+    private int correctAnswerIndex;        // 正确答案在选项中的索引（0-3）
+
+    // 无参构造（保留，用于JSON序列化）
+    public Question() {}
+
+    // 修改：全参构造（新增options和correctAnswerIndex）
+    public Question(String content, String correctAnswer, List<String> options, int correctAnswerIndex) {
+        this.content = content;
+        this.correctAnswer = correctAnswer;
+        this.options = options;
+        this.correctAnswerIndex = correctAnswerIndex;
+    }
+
+    public String getContent() {
+        return content;
+    }
+
+    public void setContent(String content) {
+        this.content = content;
+    }
+
+    public String getCorrectAnswer() {
+        return correctAnswer;
+    }
+
+    public void setCorrectAnswer(String correctAnswer) {
+        this.correctAnswer = correctAnswer;
+    }
+
+    // 新增：选项列表Getter
+    public List<String> getOptions() {
+        return options;
+    }
+
+    // 新增：选项列表Setter
+    public void setOptions(List<String> options) {
+        this.options = options;
+    }
+
+    // 新增：正确答案索引Getter
+    public int getCorrectAnswerIndex() {
+        return correctAnswerIndex;
+    }
+
+    // 新增：正确答案索引Setter
+    public void setCorrectAnswerIndex(int correctAnswerIndex) {
+        this.correctAnswerIndex = correctAnswerIndex;
+    }
+
+}

src/com/student/mathquiz/question/QuestionGenerator.java

@@ -0,0 +1,24 @@
+package com.student.mathquiz.question;
+
+import com.student.mathquiz.constant.UserType;
+
+/**
+ * 题目生成接口（修改：无方法签名变化，但实现类需生成选择题）
+ */
+public interface QuestionGenerator {
+    Question generateQuestion();
+
+    // 新增：根据用户类型获取对应的生成器（工厂方法，简化调用）
+    static QuestionGenerator getGeneratorByUserType(UserType userType) {
+        switch (userType) {
+            case PRIMARY:
+                return new PrimaryQuestionGenerator();
+            case JUNIOR:
+                return new MiddleQuestionGenerator();
+            case SENIOR:
+                return new HighQuestionGenerator();
+            default:
+                throw new IllegalArgumentException("不支持的用户类型：" + userType.getDisplayName());
+        }
+    }
+}

src/com/student/mathquiz/quiz/Quiz.java

@@ -0,0 +1,72 @@
+package com.student.mathquiz.quiz;
+
+import com.student.mathquiz.question.Question;
+import com.student.mathquiz.user.User;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 试卷实体类（新增：存储试卷题目、答题记录、分数）
+ */
+public class Quiz {
+    private String quizId;                // 试卷唯一ID（时间戳+随机数）
+    private User user;                    // 关联的用户
+    private List<Question> questions;     // 题目列表（10-30道）
+    private List<Integer> userAnswers;    // 用户答题记录（存储选项索引）
+    private int score;                    // 最终分数（百分制）
+    private long createTime;              // 试卷创建时间
+
+    // 构造方法
+    public Quiz(User user, List<Question> questions) {
+        this.quizId = System.currentTimeMillis() + "-" + (int)(Math.random()*1000); // 唯一ID
+        this.user = user;
+        this.questions = questions;
+        this.userAnswers = new ArrayList<>(); // 初始化答题记录
+        this.createTime = System.currentTimeMillis();
+        this.score = 0; // 初始分数0
+    }
+
+    // 提交答案（新增：记录用户选择的选项索引）
+    public void submitAnswer(int optionIndex) {
+        userAnswers.add(optionIndex);
+    }
+
+    // 计算分数（新增：根据答题记录与正确答案对比）
+    public void calculateScore() {
+        if (questions.size() != userAnswers.size()) {
+            score = 0; // 题目未答完，分数0
+            return;
+        }
+
+        int correctCount = 0;
+        for (int i = 0; i < questions.size(); i++) {
+            Question question = questions.get(i);
+            int userAnswerIndex = userAnswers.get(i);
+            // 对比用户答案与正确答案索引
+            if (userAnswerIndex == question.getCorrectAnswerIndex()) {
+                correctCount++;
+            }
+        }
+
+        // 分数 = 正确率 × 100（百分制）
+        score = (int) (((double) correctCount / questions.size()) * 100);
+    }
+
+    // Getter/Setter（略，按需生成）
+    public String getQuizId() {
+        return quizId;
+    }
+
+    public List<Question> getQuestions() {
+        return questions;
+    }
+
+    public List<Integer> getUserAnswers() {
+        return userAnswers;
+    }
+
+    public int getScore() {
+        return score;
+    }
+}

src/com/student/mathquiz/quiz/QuizService.java

@@ -0,0 +1,99 @@
+package com.student.mathquiz.quiz;
+
+import com.student.mathquiz.constant.Constants;
+import com.student.mathquiz.constant.UserType;
+import com.student.mathquiz.question.Question;
+import com.student.mathquiz.question.QuestionGenerator;
+import com.student.mathquiz.user.User;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * 试卷服务类（新增：生成去重试卷、处理答题、计算分数）
+ */
+public class QuizService {
+    // 生成试卷（指定用户、题目数量，确保同一张卷子无重复题目）
+    public Quiz generateQuiz(User user, int questionCount) {
+        // 1. 验证题目数量（10-30道）
+        if (questionCount < Constants.QUESTION_MIN_COUNT || questionCount > Constants.QUESTION_MAX_COUNT) {
+            throw new IllegalArgumentException("题目数量需在10-30之间！");
+        }
+
+        // 2. 获取对应学段的题目生成器
+        UserType userType = user.getUserType();
+        QuestionGenerator generator = QuestionGenerator.getGeneratorByUserType(userType);
+
+        // 3. 生成题目（去重：用Set存储题干，避免重复）
+        Set<String> questionContentSet = new HashSet<>();
+        List<Question> questions = new ArrayList<>();
+        int maxTries = questionCount * 200; // 最大尝试次数（避免死循环）
+        int tries = 0;
+
+        while (questions.size() < questionCount && tries < maxTries) {
+            Question question = generator.generateQuestion();
+            String content = question.getContent();
+            // 若题干未重复，添加到试卷
+            if (!questionContentSet.contains(content)) {
+                questionContentSet.add(content);
+                questions.add(question);
+            }
+            tries++;
+        }
+
+        // 4. 检查是否生成足够题目
+        if (questions.size() < questionCount) {
+            throw new RuntimeException("生成题目不足，建议减少题目数量！");
+        }
+
+        // 5. 创建试卷
+        return new Quiz(user, questions);
+    }
+
+    // 提交答案（指定试卷、题目索引、用户选择的选项索引）
+    public void submitAnswer(Quiz quiz, int questionIndex, int optionIndex) {
+        // 验证题目索引合法性
+        if (questionIndex < 0 || questionIndex >= quiz.getQuestions().size()) {
+            throw new IllegalArgumentException("题目索引无效！");
+        }
+        // 验证选项索引合法性（0-3）
+        if (optionIndex < 0 || optionIndex >= 4) {
+            throw new IllegalArgumentException("选项索引需为0-3！");
+        }
+        // 提交答案（覆盖已有答案，支持修改）
+        List<Integer> userAnswers = quiz.getUserAnswers();
+        if (userAnswers.size() > questionIndex) {
+            userAnswers.set(questionIndex, optionIndex); // 修改已有答案
+        } else {
+            userAnswers.add(optionIndex); // 新增答案
+        }
+    }
+
+    // 计算试卷分数
+    public int calculateQuizScore(Quiz quiz) {
+        quiz.calculateScore();
+        return quiz.getScore();
+    }
+
+    // 测试：生成试卷并答题
+    public static void main(String[] args) {
+        // 模拟用户
+        User user = new User("test@primary.com", "encryptedPwd", UserType.PRIMARY);
+        // 生成10道题的试卷
+        QuizService quizService = new QuizService();
+        Quiz quiz = quizService.generateQuiz(user, 10);
+        System.out.println("生成试卷ID：" + quiz.getQuizId());
+        System.out.println("题目数量：" + quiz.getQuestions().size());
+
+        // 模拟答题（每道题选第0个选项）
+        for (int i = 0; i < quiz.getQuestions().size(); i++) {
+            quizService.submitAnswer(quiz, i, 0);
+        }
+
+        // 计算分数
+        int score = quizService.calculateQuizScore(quiz);
+        System.out.println("最终分数：" + score);
+    }
+}

src/com/student/mathquiz/test/JsonUtilsTest.java

@@ -0,0 +1,62 @@
+package com.student.mathquiz.test;
+
+import com.google.gson.reflect.TypeToken;
+import com.student.mathquiz.persistence.JsonUtils;
+import com.student.mathquiz.user.User;
+import com.student.mathquiz.constant.UserType;
+
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 测试 JsonUtils 工具类（写文件+读文件）
+ */
+public class JsonUtilsTest {
+    public static void main(String[] args) {
+        // 测试1：写用户列表到JSON文件
+        testWriteJson();
+
+        // 测试2：从JSON文件读用户列表
+        testReadJson();
+    }
+
+    // 测试1：写JSON文件
+    private static void testWriteJson() {
+        System.out.println("=== 测试写JSON文件 ===");
+        // 1. 创建测试用户列表
+        List<User> testUsers = new ArrayList<>();
+        testUsers.add(new User("test1@qq.com", "EncPwd123", UserType.PRIMARY)); // 小学用户
+        testUsers.add(new User("test2@qq.com", "EncPwd456", UserType.JUNIOR));  // 初中用户
+
+        // 2. 调用JsonUtils写文件（路径：user_data/test_users.json）
+        boolean writeSuccess = JsonUtils.writeToJson("user_data/test_users.json", testUsers);
+
+        // 3. 验证结果
+        if (writeSuccess) {
+            System.out.println("✅ 写文件成功！可在项目根目录下查看 user_data/test_users.json");
+        } else {
+            System.out.println("❌ 写文件失败！检查路径或权限");
+        }
+    }
+
+    // 测试2：读JSON文件
+    private static void testReadJson() {
+        System.out.println("\n=== 测试读JSON文件 ===");
+        // 1. 获取List<User>的真实类型（解决泛型擦除）
+        Type userListType = new TypeToken<List<User>>() {}.getType();
+
+        // 2. 调用JsonUtils读文件
+        List<User> readUsers = JsonUtils.readFromJson("user_data/test_users.json", userListType);
+
+        // 3. 验证结果
+        if (readUsers == null || readUsers.isEmpty()) {
+            System.out.println("❌ 读文件失败！文件不存在或格式错误");
+        } else {
+            System.out.println("✅ 读文件成功！读取到 " + readUsers.size() + " 个用户：");
+            for (User user : readUsers) {
+                System.out.println("邮箱：" + user.getEmail() + "，学段：" + user.getUserType().getDisplayName());
+            }
+        }
+    }
+}

src/com/student/mathquiz/test/QuestionGeneratorTest.java

@@ -0,0 +1,75 @@
+package com.student.mathquiz.test;
+
+import com.student.mathquiz.constant.UserType;
+import com.student.mathquiz.question.Question;
+import com.student.mathquiz.question.QuestionGenerator;
+
+/**
+ * 测试题目生成模块：验证不同学段题目是否符合要求
+ */
+public class QuestionGeneratorTest {
+    public static void main(String[] args) {
+        System.out.println("=== 开始测试题目生成 ===");
+
+        // 测试1：小学题目（四则运算+括号）
+        testQuestionGenerator(UserType.PRIMARY, "小学");
+
+        // 测试2：初中题目（平方/根号）
+        testQuestionGenerator(UserType.JUNIOR, "初中");
+
+        // 测试3：高中题目（三角函数）
+        testQuestionGenerator(UserType.SENIOR, "高中");
+
+        System.out.println("\n=== 题目生成测试结束 ===");
+    }
+
+    /**
+     * 测试指定学段的题目生成
+     * @param userType 学段类型
+     * @param typeName 学段名称（用于控制台显示）
+     */
+    private static void testQuestionGenerator(UserType userType, String typeName) {
+        System.out.println("\n【" + typeName + "题目测试】");
+        // 获取对应学段的生成器（你的业务代码）
+        QuestionGenerator generator = QuestionGenerator.getGeneratorByUserType(userType);
+
+        // 生成5道题，验证每道题的合法性
+        for (int i = 0; i < 5; i++) {
+            Question question = generator.generateQuestion();
+
+            // 验证1：题干符合学段要求
+            boolean isContentValid = checkContentValid(question.getContent(), userType);
+            // 验证2：选项数量为4个
+            boolean isOptionCountValid = question.getOptions().size() == 4;
+            // 验证3：正确答案索引在0-3之间
+            boolean isIndexValid = question.getCorrectAnswerIndex() >= 0 && question.getCorrectAnswerIndex() <= 3;
+
+            // 输出结果
+            System.out.println("第" + (i+1) + "题：");
+            System.out.println("  题干：" + question.getContent());
+            System.out.println("  选项：" + question.getOptions());
+            System.out.println("  正确索引：" + question.getCorrectAnswerIndex());
+            System.out.println("  验证结果：" + (isContentValid && isOptionCountValid && isIndexValid ? "✅ 合法" : "❌ 非法"));
+        }
+    }
+
+    /**
+     * 检查题干是否符合学段要求
+     */
+    private static boolean checkContentValid(String content, UserType userType) {
+        switch (userType) {
+            case PRIMARY:
+                // 小学：含 +-*/，可含()，不含平方/根号/三角函数
+                return (content.contains("+") || content.contains("-") || content.contains("*") || content.contains("/"))
+                        && !content.contains("^2") && !content.contains("sqrt") && !content.contains("sin") && !content.contains("cos") && !content.contains("tan");
+            case JUNIOR:
+                // 初中：含平方（^2）或根号（sqrt）
+                return content.contains("^2") || content.contains("sqrt");
+            case SENIOR:
+                // 高中：含三角函数（sin/cos/tan）
+                return content.contains("sin") || content.contains("cos") || content.contains("tan");
+            default:
+                return false;
+        }
+    }
+}

src/com/student/mathquiz/test/QuizServiceTest.java

@@ -0,0 +1,114 @@
+package com.student.mathquiz.test;
+
+import com.student.mathquiz.constant.UserType;
+import com.student.mathquiz.question.Question;
+import com.student.mathquiz.quiz.Quiz;
+import com.student.mathquiz.quiz.QuizService;
+import com.student.mathquiz.user.User;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * 测试试卷服务：生成试卷（去重）、答题、评分
+ */
+public class QuizServiceTest {
+    public static void main(String[] args) {
+        System.out.println("=== 开始测试试卷服务 ===");
+
+        // 1. 模拟一个登录用户（实际项目中从登录接口获取）
+        User testUser = new User("quiz_test@163.com", "EncPwd123", UserType.JUNIOR);
+        System.out.println("测试用户：" + testUser.getEmail() + "（" + testUser.getUserType().getDisplayName() + "）\n");
+
+        // 2. 初始化试卷服务（你的业务代码）
+        QuizService quizService = new QuizService();
+
+        // 3. 生成试卷（10道题，验证去重）
+        Quiz quiz = testGenerateQuiz(quizService, testUser, 10);
+
+        // 4. 模拟答题（每道题选第0个选项）
+        if (quiz != null) {
+            testSubmitAnswer(quizService, quiz);
+
+            // 5. 计算分数
+            testCalculateScore(quizService, quiz);
+        }
+
+        System.out.println("\n=== 试卷服务测试结束 ===");
+    }
+
+    // 场景1：生成试卷，验证是否去重
+    private static Quiz testGenerateQuiz(QuizService quizService, User user, int questionCount) {
+        System.out.println("【场景1：生成试卷（" + questionCount + "道题）】");
+        try {
+            Quiz quiz = quizService.generateQuiz(user, questionCount);
+            List<Question> questions = quiz.getQuestions();
+
+            // 验证1：题目数量正确
+            boolean isCountValid = questions.size() == questionCount;
+
+            // 验证2：题目无重复（用Set存题干，判断大小是否等于题目数量）
+            Set<String> contentSet = new HashSet<>();
+            for (Question q : questions) {
+                contentSet.add(q.getContent());
+            }
+            boolean isNoDuplicate = contentSet.size() == questionCount;
+
+            // 输出结果
+            System.out.println("生成题目数量：" + questions.size() + "（预期：" + questionCount + "）");
+            System.out.println("题目是否去重：" + (isNoDuplicate ? "✅ 无重复" : "❌ 有重复"));
+
+            if (isCountValid && isNoDuplicate) {
+                System.out.println("✅ 试卷生成成功！\n");
+                return quiz;
+            } else {
+                System.out.println("❌ 试卷生成失败！\n");
+                return null;
+            }
+        } catch (IllegalArgumentException e) {
+            System.out.println("❌ 生成失败：" + e.getMessage() + "\n");
+            return null;
+        }
+    }
+
+    // 场景2：模拟答题（每道题选第0个选项）
+    private static void testSubmitAnswer(QuizService quizService, Quiz quiz) {
+        System.out.println("【场景2：模拟答题】");
+        List<Question> questions = quiz.getQuestions();
+
+        for (int i = 0; i < questions.size(); i++) {
+            // 提交第i题的答案（选第0个选项）
+            quizService.submitAnswer(quiz, i, 0);
+            System.out.println("第" + (i+1) + "题：提交选项0（题干：" + questions.get(i).getContent() + "）");
+        }
+
+        // 验证：答题记录数量是否等于题目数量
+        boolean isAnswerCountValid = quiz.getUserAnswers().size() == questions.size();
+        System.out.println("答题记录验证：" + (isAnswerCountValid ? "✅ 记录完整" : "❌ 记录缺失") + "\n");
+    }
+
+    // 场景3：计算分数
+    private static void testCalculateScore(QuizService quizService, Quiz quiz) {
+        System.out.println("【场景3：计算分数】");
+        int score = quizService.calculateQuizScore(quiz);
+        List<Question> questions = quiz.getQuestions();
+        List<Integer> userAnswers = quiz.getUserAnswers();
+
+        // 统计答对数量
+        int correctCount = 0;
+        for (int i = 0; i < questions.size(); i++) {
+            Question q = questions.get(i);
+            if (userAnswers.get(i) == q.getCorrectAnswerIndex()) {
+                correctCount++;
+            }
+        }
+        int expectedScore = (int) (((double) correctCount / questions.size()) * 100);
+
+        // 验证：计算的分数是否符合预期
+        boolean isScoreValid = score == expectedScore;
+        System.out.println("答对题目：" + correctCount + "/" + questions.size());
+        System.out.println("最终分数：" + score + "分（预期：" + expectedScore + "分）");
+        System.out.println("分数验证：" + (isScoreValid ? "✅ 分数正确" : "❌ 分数错误"));
+    }
+}

src/com/student/mathquiz/test/UserServiceTest.java

@@ -0,0 +1,119 @@
+package com.student.mathquiz.test;
+
+import com.student.mathquiz.constant.UserType;
+import com.student.mathquiz.user.User;
+import com.student.mathquiz.user.UserFileService;
+import com.student.mathquiz.user.UserService;
+
+/**
+ * 测试用户模块：注册、登录、改密码（覆盖评分细则所有场景）
+ */
+public class UserServiceTest {
+    // 初始化用户服务（你的业务代码）
+    private static final UserService userService = new UserFileService();
+    // 测试用邮箱（可替换成自己的邮箱）
+    private static final String TEST_EMAIL = "test_student@163.com";
+    // 测试用密码（符合规则：6-10位+大小写+数字）
+    private static final String TEST_PWD = "Test1234";
+    // 错误密码（不符合规则：无大写）
+    private static final String WRONG_PWD = "test1234";
+
+    public static void main(String[] args) {
+        System.out.println("=== 开始测试用户模块 ===\n");
+
+        // 场景1：测试邮箱格式校验（输入非法邮箱）
+        testInvalidEmail();
+
+        // 场景2：测试发送验证码
+        String verifyCode = testSendVerifyCode();
+
+        // 场景3：测试正常注册（合法邮箱+正确验证码+合规密码）
+        testNormalRegister(verifyCode);
+
+        // 场景4：测试重复注册（同一邮箱再次注册）
+        testDuplicateRegister(verifyCode);
+
+        // 场景5：测试登录（正确邮箱+正确密码）
+        User loginUser = testNormalLogin();
+
+        // 场景6：测试修改密码（正确原密码+合规新密码）
+        if (loginUser != null) {
+            testChangePassword();
+        }
+
+        System.out.println("\n=== 用户模块测试结束 ===");
+    }
+
+    // 场景1：测试非法邮箱（如无@、无后缀）
+    private static void testInvalidEmail() {
+        System.out.println("【场景1：非法邮箱校验】");
+        String invalidEmail = "test163.com"; // 无@
+        boolean isvalid = userService.isValidEmail(invalidEmail);
+        if (!isvalid) {
+            System.out.println("✅ 正确：非法邮箱被拦截（" + invalidEmail + "）\n");
+        } else {
+            System.out.println("❌ 错误：非法邮箱未被拦截（" + invalidEmail + "）\n");
+        }
+    }
+
+    // 场景2：发送验证码（模拟前端获取验证码）
+    private static String testSendVerifyCode() {
+        System.out.println("【场景2：发送验证码】");
+        String verifyCode = userService.sendVerifyCode(TEST_EMAIL);
+        System.out.println("✅ 验证码已发送（控制台查看），测试用验证码：" + verifyCode + "\n");
+        return verifyCode; // 返回验证码，用于后续注册
+    }
+
+    // 场景3：正常注册（符合所有规则）
+    private static void testNormalRegister(String verifyCode) {
+        System.out.println("【场景3：正常注册】");
+        // 调用注册方法（邮箱+验证码+合规密码+小学学段）
+        boolean isSuccess = userService.register(TEST_EMAIL, verifyCode, TEST_PWD, UserType.PRIMARY);
+        if (isSuccess) {
+            System.out.println("✅ 注册成功！（邮箱：" + TEST_EMAIL + "，密码：" + TEST_PWD + "）\n");
+        } else {
+            System.out.println("❌ 注册失败！检查验证码或邮箱是否已注册\n");
+        }
+    }
+
+    // 场景4：重复注册（同一邮箱再次注册）
+    private static void testDuplicateRegister(String verifyCode) {
+        System.out.println("【场景4：重复注册】");
+        boolean isSuccess = userService.register(TEST_EMAIL, verifyCode, TEST_PWD, UserType.PRIMARY);
+        if (!isSuccess) {
+            System.out.println("✅ 正确：重复注册被拦截（邮箱已存在）\n");
+        } else {
+            System.out.println("❌ 错误：允许重复注册（违反评分细则）\n");
+        }
+    }
+
+    // 场景5：正常登录（正确邮箱+密码）
+    private static User testNormalLogin() {
+        System.out.println("【场景5：正常登录】");
+        User user = userService.login(TEST_EMAIL, TEST_PWD);
+        if (user != null) {
+            System.out.println("✅ 登录成功！用户信息：邮箱=" + user.getEmail() + "，学段=" + user.getUserType().getDisplayName() + "\n");
+            return user;
+        } else {
+            System.out.println("❌ 登录失败！检查邮箱或密码\n");
+            return null;
+        }
+    }
+
+    // 场景6：修改密码（正确原密码+新密码）
+    private static void testChangePassword() {
+        System.out.println("【场景6：修改密码】");
+        String newPwd = "NewTest567"; // 新密码（合规）
+        // 调用改密码方法（原密码正确）
+        boolean isSuccess = userService.changePassword(TEST_EMAIL, TEST_PWD, newPwd);
+        if (isSuccess) {
+            // 验证新密码是否能登录
+            User user = userService.login(TEST_EMAIL, newPwd);
+            if (user != null) {
+                System.out.println("✅ 密码修改成功！新密码可正常登录（新密码：" + newPwd + "）\n");
+            }
+        } else {
+            System.out.println("❌ 密码修改失败！检查原密码是否正确或新密码是否合规\n");
+        }
+    }
+}

src/com/student/mathquiz/user/User.java

@@ -0,0 +1,59 @@
+package com.student.mathquiz.user;
+
+import com.student.mathquiz.constant.UserType;
+
+import java.io.Serializable;
+
+/**
+ * 用户实体类：存储用户核心信息
+ */
+public class User implements Serializable {
+    private String email;          // 用户名（邮箱）
+    private String encryptedPwd;   // 加密后的密码（避免明文存储）
+    private UserType userType;     // 用户选择的学段（小学/初中/高中）
+    private long registerTime;     // 注册时间（时间戳，用于追踪）
+
+    // 无参构造（Gson序列化需要）
+    public User() {}
+
+    // 全参构造
+    public User(String email, String encryptedPwd, UserType userType) {
+        this.email = email;
+        this.encryptedPwd = encryptedPwd;
+        this.userType = userType;
+        this.registerTime = System.currentTimeMillis(); // 自动记录注册时间
+    }
+
+    // Getter/Setter（必须，Gson需要通过Getter读取属性）
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public String getEncryptedPwd() {
+        return encryptedPwd;
+    }
+
+    public void setEncryptedPwd(String encryptedPwd) {
+        this.encryptedPwd = encryptedPwd;
+    }
+
+    public UserType getUserType() {
+        return userType;
+    }
+
+    public void setUserType(UserType userType) {
+        this.userType = userType;
+    }
+
+    public long getRegisterTime() {
+        return registerTime;
+    }
+
+    public void setRegisterTime(long registerTime) {
+        this.registerTime = registerTime;
+    }
+}

src/com/student/mathquiz/user/UserFileService.java

@@ -0,0 +1,228 @@
+package com.student.mathquiz.user;
+
+import com.google.gson.reflect.TypeToken;
+import com.student.mathquiz.constant.Constants;
+import com.student.mathquiz.constant.UserType;
+import com.student.mathquiz.persistence.JsonUtils;
+
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.Base64;
+
+/**
+ * 用户服务接口：定义用户操作规范，解耦实现
+ */
+public class UserFileService implements UserService {
+    // 存储用户数据的JSON文件路径（从常量类获取）
+    private static final String USER_DATA_PATH = Constants.USER_DATA_PATH;
+    // 存储用户列表的类型（Gson反序列化需要）
+    private static final Type USER_LIST_TYPE = new TypeToken<List<User>>() {}.getType();
+    // 验证码缓存（模拟：实际项目可用Redis，这里用内存缓存）
+    private final List<VerifyCodeCache> verifyCodeCache = new ArrayList<>();
+    // 随机数生成器（用于生成验证码）
+    private final Random random = new Random();
+
+    // ------------------------------ 1. 发送验证码 ------------------------------
+    @Override
+    public String sendVerifyCode(String email) {
+        // 1. 生成6位随机验证码（数字）
+        StringBuilder code = new StringBuilder();
+        for (int i = 0; i < Constants.VERIFY_CODE_LENGTH; i++) {
+            code.append(random.nextInt(10));
+        }
+        String verifyCode = code.toString();
+
+        // 2. 缓存验证码（有效期5分钟，避免重复使用）
+        verifyCodeCache.add(new VerifyCodeCache(email, verifyCode, System.currentTimeMillis() + 5 * 60 * 1000));
+
+        // 3. 模拟发送（控制台输出，实际项目替换为邮件发送逻辑）
+        System.out.println("[验证码发送] 邮箱：" + email + "，验证码：" + verifyCode + "（有效期5分钟）");
+
+        return verifyCode;
+    }
+
+    // ------------------------------ 2. 验证邮箱格式 ------------------------------
+    @Override
+    public boolean isValidEmail(String email) {
+        if (email == null || email.isEmpty()) {
+            return false;
+        }
+        // 邮箱格式正则（简单校验：包含@和.）
+        String emailRegex = "^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$";
+        return email.matches(emailRegex);
+    }
+
+    // ------------------------------ 3. 用户注册 ------------------------------
+    @Override
+    public boolean register(String email, String verifyCode, String password, UserType userType) {
+        // 步骤1：验证邮箱格式
+        if (!isValidEmail(email)) {
+            System.out.println("[注册失败] 邮箱格式不正确！");
+            return false;
+        }
+
+        // 步骤2：检查邮箱是否已注册
+        if (isEmailRegistered(email)) {
+            System.out.println("[注册失败] 该邮箱已注册！");
+            return false;
+        }
+
+        // 步骤3：验证验证码（是否存在、未过期、匹配）
+        VerifyCodeCache validCache = verifyCodeCache.stream()
+                .filter(cache -> cache.getEmail().equals(email)
+                        && cache.getExpireTime() > System.currentTimeMillis()
+                        && cache.getVerifyCode().equals(verifyCode))
+                .findFirst()
+                .orElse(null);
+        if (validCache == null) {
+            System.out.println("[注册失败] 验证码无效或已过期！");
+            return false;
+        }
+
+        // 步骤4：验证密码规则（6-10位，含大小写+数字）
+        if (!password.matches(Constants.PASSWORD_REGEX)) {
+            System.out.println("[注册失败] 密码需6-10位，含大小写字母和数字！");
+            return false;
+        }
+
+        // 步骤5：加密密码（Base64简单加密，实际项目可用MD5+盐值）
+        String encryptedPwd = Base64.getEncoder().encodeToString(password.getBytes());
+
+        // 步骤6：读取现有用户列表
+        List<User> userList = JsonUtils.readFromJson(USER_DATA_PATH, USER_LIST_TYPE);
+        if (userList == null) {
+            userList = new ArrayList<>(); // 首次注册，创建空列表
+        }
+
+        // 步骤7：添加新用户
+        userList.add(new User(email, encryptedPwd, userType));
+
+        // 步骤8：写入JSON文件
+        boolean writeSuccess = JsonUtils.writeToJson(USER_DATA_PATH, userList);
+        if (writeSuccess) {
+            System.out.println("[注册成功] 邮箱：" + email + "，学段：" + userType.getDisplayName());
+            // 移除已使用的验证码（避免重复注册）
+            verifyCodeCache.remove(validCache);
+            return true;
+        } else {
+            System.out.println("[注册失败] 数据存储失败！");
+            return false;
+        }
+    }
+
+    // ------------------------------ 4. 用户登录 ------------------------------
+    @Override
+    public User login(String email, String password) {
+        // 步骤1：验证邮箱格式
+        if (!isValidEmail(email)) {
+            System.out.println("[登录失败] 邮箱格式不正确！");
+            return null;
+        }
+
+        // 步骤2：读取用户列表
+        List<User> userList = JsonUtils.readFromJson(USER_DATA_PATH, USER_LIST_TYPE);
+        if (userList == null || userList.isEmpty()) {
+            System.out.println("[登录失败] 暂无注册用户！");
+            return null;
+        }
+
+        // 步骤3：加密输入的密码（与存储的加密方式一致）
+        String encryptedInputPwd = Base64.getEncoder().encodeToString(password.getBytes());
+
+        // 步骤4：匹配用户（邮箱+密码）
+        for (User user : userList) {
+            if (user.getEmail().equals(email) && user.getEncryptedPwd().equals(encryptedInputPwd)) {
+                System.out.println("[登录成功] 欢迎：" + email + "（" + user.getUserType().getDisplayName() + "）");
+                return user; // 登录成功，返回用户信息
+            }
+        }
+
+        // 步骤5：匹配失败
+        System.out.println("[登录失败] 邮箱或密码错误！");
+        return null;
+    }
+
+    // ------------------------------ 5. 修改密码 ------------------------------
+    @Override
+    public boolean changePassword(String email, String oldPassword, String newPassword) {
+        // 步骤1：验证原密码（先登录逻辑）
+        User user = login(email, oldPassword);
+        if (user == null) {
+            System.out.println("[修改失败] 原密码错误！");
+            return false;
+        }
+
+        // 步骤2：验证新密码规则
+        if (!newPassword.matches(Constants.PASSWORD_REGEX)) {
+            System.out.println("[修改失败] 新密码需6-10位，含大小写字母和数字！");
+            return false;
+        }
+
+        // 步骤3：读取用户列表
+        List<User> userList = JsonUtils.readFromJson(USER_DATA_PATH, USER_LIST_TYPE);
+        if (userList == null) {
+            System.out.println("[修改失败] 用户数据不存在！");
+            return false;
+        }
+
+        // 步骤4：更新用户密码
+        for (User u : userList) {
+            if (u.getEmail().equals(email)) {
+                // 加密新密码
+                String newEncryptedPwd = Base64.getEncoder().encodeToString(newPassword.getBytes());
+                u.setEncryptedPwd(newEncryptedPwd);
+                break;
+            }
+        }
+
+        // 步骤5：写入更新后的用户列表
+        boolean writeSuccess = JsonUtils.writeToJson(USER_DATA_PATH, userList);
+        if (writeSuccess) {
+            System.out.println("[修改成功] 密码已更新，请重新登录！");
+            return true;
+        } else {
+            System.out.println("[修改失败] 数据存储失败！");
+            return false;
+        }
+    }
+
+    // ------------------------------ 6. 检查邮箱是否已注册 ------------------------------
+    @Override
+    public boolean isEmailRegistered(String email) {
+        List<User> userList = JsonUtils.readFromJson(USER_DATA_PATH, USER_LIST_TYPE);
+        if (userList == null) {
+            return false; // 无用户数据，未注册
+        }
+        // 遍历用户列表，检查邮箱是否存在
+        return userList.stream().anyMatch(user -> user.getEmail().equals(email));
+    }
+
+    // ------------------------------ 内部类：验证码缓存 ------------------------------
+    private static class VerifyCodeCache {
+        private String email;       // 关联的邮箱
+        private String verifyCode;  // 验证码
+        private long expireTime;    // 过期时间（时间戳）
+
+        public VerifyCodeCache(String email, String verifyCode, long expireTime) {
+            this.email = email;
+            this.verifyCode = verifyCode;
+            this.expireTime = expireTime;
+        }
+
+        // Getter（用于过滤缓存）
+        public String getEmail() {
+            return email;
+        }
+
+        public String getVerifyCode() {
+            return verifyCode;
+        }
+
+        public long getExpireTime() {
+            return expireTime;
+        }
+    }
+
+}

src/com/student/mathquiz/user/UserService.java

@@ -0,0 +1,23 @@
+package com.student.mathquiz.user;
+
+import com.student.mathquiz.constant.UserType;
+
+public interface UserService {
+    // 1. 发送注册验证码（模拟：控制台输出，实际可对接邮件服务）
+    String sendVerifyCode(String email);
+
+    // 2. 验证邮箱格式
+    boolean isValidEmail(String email);
+
+    // 3. 注册用户（需验证验证码、密码规则、避免重复注册）
+    boolean register(String email, String verifyCode, String password, UserType userType);
+
+    // 4. 用户登录（邮箱+密码验证）
+    User login(String email, String password);
+
+    // 5. 修改密码（需验证原密码，新密码符合规则）
+    boolean changePassword(String email, String oldPassword, String newPassword);
+
+    // 6. 检查邮箱是否已注册
+    boolean isEmailRegistered(String email);
+}

src/question/HighQuestionGenerator.java

@@ -1,26 +0,0 @@
-package question;
-
-import java.util.Random;
-
-public class HighQuestionGenerator implements QuestionGenerator {
-    private static final Random random = new Random();
-    private final QuestionGenerator primaryGenerator = new PrimaryQuestionGenerator();
-
-    @Override
-    public Question generateQuestion() {
-        Question q = primaryGenerator.generateQuestion();
-        String[] funcs = {"sin", "cos", "tan"};
-        String func = funcs[random.nextInt(funcs.length)];
-        return new Question(func + "(" + q.getQuestion() + ")", evaluate(func, q.getQuestion()));
-    }
-
-    private String evaluate(String func, String expr) {
-        try {
-            javax.script.ScriptEngineManager mgr = new javax.script.ScriptEngineManager();
-            javax.script.ScriptEngine engine = mgr.getEngineByName("JavaScript");
-            return String.valueOf(engine.eval("Math." + func + "(Math.toRadians(" + expr + "))"));
-        } catch (Exception e) {
-            return "?";
-        }
-    }
-}

src/question/MiddleQuestionGenerator.java

@@ -1,28 +0,0 @@
-package question;
-
-import java.util.Random;
-
-public class MiddleQuestionGenerator implements QuestionGenerator {
-    private static final Random random = new Random();
-    private final QuestionGenerator primaryGenerator = new PrimaryQuestionGenerator();
-
-    @Override
-    public Question generateQuestion() {
-        Question q = primaryGenerator.generateQuestion();
-        if (random.nextBoolean()) {
-            return new Question(q.getQuestion() + " ^ 2", evaluate(q.getQuestion() + "^2"));
-        } else {
-            return new Question("√" + q.getQuestion(), evaluate("Math.sqrt(" + q.getQuestion() + ")"));
-        }
-    }
-
-    private String evaluate(String expr) {
-        try {
-            javax.script.ScriptEngineManager mgr = new javax.script.ScriptEngineManager();
-            javax.script.ScriptEngine engine = mgr.getEngineByName("JavaScript");
-            return String.valueOf(engine.eval(expr.replace("^", "**")));
-        } catch (Exception e) {
-            return "?";
-        }
-    }
-}

src/question/PrimaryQuestionGenerator.java

@@ -1,65 +0,0 @@
-package question;
-
-import java.util.Random;
-
-public class PrimaryQuestionGenerator implements QuestionGenerator {
-    private static final Random random = new Random();
-
-    @Override
-    public Question generateQuestion() {
-        int numOperands = random.nextInt(5) + 1;
-        StringBuilder sb = new StringBuilder();
-        int currentValue = random.nextInt(100) + 1;
-        sb.append(currentValue);
-
-        for (int i = 1; i < numOperands; i++) {
-            String[] ops = {"+", "-", "*", "/"};
-            String op;
-            int nextVal;
-            do {
-                op = ops[random.nextInt(ops.length)];
-                nextVal = random.nextInt(100) + 1;
-            } while ((op.equals("-") && currentValue < nextVal) ||
-                    (op.equals("/") && (nextVal == 0 || currentValue % nextVal != 0)));
-
-            sb.append(" ").append(op).append(" ").append(nextVal);
-            switch (op) {
-                case "+": currentValue += nextVal; break;
-                case "-": currentValue -= nextVal; break;
-                case "*": currentValue *= nextVal; break;
-                case "/": currentValue /= nextVal; break;
-            }
-        }
-
-        String expr = addParentheses(sb.toString());
-        return new Question(expr, evaluate(expr));
-    }
-
-    private String addParentheses(String expr) {
-        String[] tokens = expr.split(" ");
-        if (tokens.length < 3) return expr;
-
-        int start = random.nextInt(tokens.length / 2) * 2;
-        int end = start + 2 + random.nextInt((tokens.length - start) / 2) * 2;
-        end = Math.min(end, tokens.length - 1);
-
-        StringBuilder newExpr = new StringBuilder();
-        for (int i = 0; i < tokens.length; i++) {
-            if (i == start) newExpr.append("(");
-            newExpr.append(tokens[i]);
-            if (i == end) newExpr.append(")");
-            if (i != tokens.length - 1) newExpr.append(" ");
-        }
-        return newExpr.toString();
-    }
-
-    private String evaluate(String expr) {
-        try {
-            javax.script.ScriptEngineManager mgr = new javax.script.ScriptEngineManager();
-            javax.script.ScriptEngine engine = mgr.getEngineByName("JavaScript");
-            return String.valueOf(engine.eval(expr));
-        } catch (Exception e) {
-            return "?";
-        }
-    }
-}

src/question/Question.java

@@ -1,20 +0,0 @@
-package question;
-
-public class Question {
-    private String question;
-    private String answer;
-
-    public Question(String question, String answer) {
-        this.question = question;
-        this.answer = answer;
-    }
-
-    public String getQuestion() {
-        return question;
-    }
-
-    public String getAnswer() {
-        return answer;
-    }
-
-}

src/question/QuestionGenerator.java

@@ -1,5 +0,0 @@
-package question;
-
-public interface QuestionGenerator {
-    Question generateQuestion();
-}