# 从零开始实现数学题目的作答小游戏
*开源技术栏*

使用 Mathematical_Expression 让计算机做出题人，让代码与数学碰撞出趣味火花。


## 目录

[TOC]

![文章的封面](https://diskmirror.lingyuzhao.top/1/Binary/Article/Image/94267819/1720877497509.jpg "文章的封面")

# 从零开始实现数学题目的作答小游戏：让代码与数学碰撞出趣味火花

数学，是逻辑与创造力的交汇点；而编程，则是将抽象思维转化为具体实践的桥梁。当二者相遇，会擦出怎样的火花？本文将带你用Java代码构建一款动态数学答题小游戏，通过随机生成数学题目、实时计算答案、交互式答题等功能，让学习数学的过程充满趣味性。更令人兴奋的是，我们将借助开源库 mathematical-expression 的强大能力，让代码自动解析和运算复杂的数学表达式，彻底解放开发者对"题目生成器"的实现难度。

## 为什么选择动态数学题目？
传统的数学练习往往局限于静态题库，而动态生成的题目系统能带来三大优势：

- 无限题库：通过算法随机组合数字与运算符，每次运行都产生全新题目；

- 难度自适应：可灵活控制运算符类型（加减乘除、括号等）和数值范围；

- 即时验证：利用表达式解析库自动判断用户答案的正确性。

## 来看一段核心代码的讲解

首先将依赖引入

```xml
    <dependencies>
        <dependency>
            <groupId>io.github.BeardedManZhao</groupId>
            <artifactId>mathematical-expression</artifactId>
            <version>1.5.7</version>
        </dependency>
    </dependencies>
```

然后是我们要展示的代码！

```java
package org.example;

import io.github.beardedManZhao.mathematicalExpression.core.Mathematical_Expression;
import io.github.beardedManZhao.mathematicalExpression.core.calculation.number.JvmCalculation;
import io.github.beardedManZhao.mathematicalExpression.core.container.JvmExpression;

public class Main {
    public static void main(String[] args) {
        // 获取到一个Jvm计算组件
        JvmCalculation instance = (JvmCalculation) Mathematical_Expression.getInstance(Mathematical_Expression.jvmCalculation);
        // 将一个表达式进行编译
        JvmExpression compile = instance.compile("1 + 1 - 1 * 1", false);
        // 设置不同位置的操作数的值 用来改变表达式
        compile.setParamNumber(0, 2);
        compile.setParamNumber(1, 3);
        compile.setParamNumber(3, 4);
        // 打印出表达式的结果
        System.out.println(compile.getExpressionStrAndNumber());
    }
}
```
运行结果会输出：`2.0 + 3.0 - 1.0 * 4.0`

这正是我们构建题目的核心思路——通过程序化修改表达式参数，即可生成千变万化的数学题！

接下来我们将开始实现

## 开始实现

### 实现不同的操作符

我们发现 对于单个表达式的操作数可以进行修改，但操作符比较单一，因此多创建一些带有不同操作符的表达式！

```
package org.example;

import io.github.beardedManZhao.mathematicalExpression.core.Mathematical_Expression;
import io.github.beardedManZhao.mathematicalExpression.core.calculation.number.JvmCalculation;
import io.github.beardedManZhao.mathematicalExpression.core.container.JvmExpression;

public class Main {

    public static void main(String[] args) {
        // 获取到一个Jvm计算组件
        JvmCalculation instance = (JvmCalculation) Mathematical_Expression.getInstance(Mathematical_Expression.jvmCalculation);
        // 编译不同操作符的表达式
        JvmExpression[] compiles = {
                instance.compile("1 + 1 - 1 * 1", false),
                instance.compile("1 - 1 / 1 * 1", false),
                instance.compile("1 + 1 - 1 / 1", false),
                instance.compile("1 + (1 - 1) * 1", false)
        };
    }
}
```

### 实现随机选择表达式功能

```
package org.example;

import io.github.beardedManZhao.mathematicalExpression.core.Mathematical_Expression;
import io.github.beardedManZhao.mathematicalExpression.core.calculation.number.JvmCalculation;
import io.github.beardedManZhao.mathematicalExpression.core.container.JvmExpression;

import java.util.Random;

public class Main {

    public static void main(String[] args) {
        // 获取到一个Jvm计算组件
        JvmCalculation instance = (JvmCalculation) Mathematical_Expression.getInstance(Mathematical_Expression.jvmCalculation);
        // 编译不同操作符的表达式
        JvmExpression[] compiles = {
                instance.compile("1 + 1 - 1 * 1", false),
                instance.compile("1 - 1 / 1 * 1", false),
                instance.compile("1 + 1 - 1 / 1", false),
                instance.compile("1 + (1 - 1) * 1", false)
        };
        // 准备一个随机生成器
        final Random random = new Random();
        // 随机选择 10 个表达式 测测看看功能是否正常
        for (int i = 0; i < 10; i++) {
            JvmExpression compile = compiles[random.nextInt(4)];
            System.out.println(compile.getExpressionStrAndNumber());
        }
    }
}
```

下面是运行结果

```
1.0 + (1.0 - 1.0) * 1.0
1.0 + (1.0 - 1.0) * 1.0
1.0 + 1.0 - 1.0 * 1.0
1.0 + 1.0 - 1.0 * 1.0
1.0 + (1.0 - 1.0) * 1.0
1.0 + 1.0 - 1.0 * 1.0
1.0 - 1.0 / 1.0 * 1.0
1.0 - 1.0 / 1.0 * 1.0
1.0 + 1.0 - 1.0 / 1.0
1.0 + (1.0 - 1.0) * 1.0
```

### 实现单个表达式操作数的随机修改功能


```
package org.example;

import io.github.beardedManZhao.mathematicalExpression.core.Mathematical_Expression;
import io.github.beardedManZhao.mathematicalExpression.core.calculation.number.JvmCalculation;
import io.github.beardedManZhao.mathematicalExpression.core.container.JvmExpression;

import java.util.Random;

public class Main {

    public static void main(String[] args) {
        // 获取到一个Jvm计算组件
        JvmCalculation instance = (JvmCalculation) Mathematical_Expression.getInstance(Mathematical_Expression.jvmCalculation);
        // 编译不同操作符的表达式
        JvmExpression[] compiles = {
                instance.compile("1 + 1 - 1 * 1", false),
                instance.compile("1 - 1 / 1 * 1", false),
                instance.compile("1 + 1 - 1 / 1", false),
                instance.compile("1 + (1 - 1) * 1", false)
        };
        // 准备一个随机生成器
        final Random random = new Random();
        // 随机选择 10 个表达式 测测看看功能是否正常
        for (int i = 0; i < 10; i++) {
            JvmExpression compile = compiles[random.nextInt(4)];
            // 依次迭代当前表达式的每个操作数
            for (int i1 = 0; i1 < compile.getLength(); i1++) {
                // 开始修改 将操作数修改为 小于等于 100 的数
                compile.setParamNumber(i1, random.nextInt(100));
            }
            // 打印表达式
            System.out.println(compile.getExpressionStrAndNumber());
        }
    }
}
```

下面是运行结果
```
31.0 + 15.0 - 83.0 * 18.0
70.0 + 7.0 - 34.0 / 85.0
84.0 + (29.0 - 65.0) * 14.0
68.0 + 75.0 - 71.0 * 49.0
57.0 - 32.0 / 30.0 * 87.0
98.0 + 35.0 - 51.0 / 51.0
10.0 - 54.0 / 28.0 * 51.0
67.0 - 3.0 / 74.0 * 23.0
0.0 + (71.0 - 14.0) * 34.0
76.0 - 16.0 / 59.0 * 65.0
```

现在可以看到表达式已经比较随机了，表达式的生成成功了！

### 实现表达式结果的计算

```
package org.example;

import io.github.beardedManZhao.mathematicalExpression.core.Mathematical_Expression;
import io.github.beardedManZhao.mathematicalExpression.core.calculation.number.JvmCalculation;
import io.github.beardedManZhao.mathematicalExpression.core.container.JvmExpression;
import zhao.utils.StrUtils;

import java.util.Random;

public class Main {

    public static void main(String[] args) {
        // 获取到一个Jvm计算组件
        JvmCalculation instance = (JvmCalculation) Mathematical_Expression.getInstance(Mathematical_Expression.jvmCalculation);
        // 编译不同操作符的表达式
        JvmExpression[] compiles = {
                instance.compile("1 + 1 - 1 * 1", false),
                instance.compile("1 - 1 / 1 * 1", false),
                instance.compile("1 + 1 - 1 / 1", false),
                instance.compile("1 + (1 - 1) * 1", false)
        };
        // 准备一个随机生成器
        final Random random = new Random();
        // 随机选择 10 个表达式 测测看看功能是否正常
        for (int i = 0; i < 10; i++) {
            JvmExpression compile = compiles[random.nextInt(4)];
            // 依次迭代当前表达式的每个操作数
            for (int i1 = 0; i1 < compile.getLength(); i1++) {
                // 开始修改 将操作数修改为 小于等于 100 的数
                compile.setParamNumber(i1, random.nextInt(100));
            }
            // 打印表达式的结果
            Double result = compile.calculation(false).getResult();
            // 判断小数位是否过长 过长的不计算了
            boolean isWireless = String.valueOf(result).split("\\.")[1].length() > 2;
            if (!isWireless) {
                // 打印表达式
                System.out.println(compile.getExpressionStrAndNumber());
                // 打印计算结果
                System.out.println(result);
            }
        }
    }
}
```

下面是运行结果

```
4.0 + (60.0 - 26.0) * 80.0
2724.0
52.0 + (82.0 - 12.0) * 52.0
3692.0
68.0 + 48.0 - 21.0 * 60.0
-1144.0
18.0 + (56.0 - 27.0) * 4.0
134.0
81.0 + (16.0 - 79.0) * 44.0
-2691.0
94.0 + 38.0 - 53.0 * 75.0
-3843.0
30.0 + (27.0 - 40.0) * 41.0
-503.0

```

### 实现与用户之间的校验（最终代码）

```java
package org.example;

import io.github.beardedManZhao.mathematicalExpression.core.Mathematical_Expression;
import io.github.beardedManZhao.mathematicalExpression.core.calculation.number.JvmCalculation;
import io.github.beardedManZhao.mathematicalExpression.core.container.JvmExpression;

import java.util.Random;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // 获取到一个Jvm计算组件
        JvmCalculation instance = (JvmCalculation) Mathematical_Expression.getInstance(Mathematical_Expression.jvmCalculation);
        // 编译不同操作符的表达式
        JvmExpression[] compiles = {
                instance.compile("1 + 1 - 1 * 1", false),
                instance.compile("1 - 1 / 1 * 1", false),
                instance.compile("1 + 1 - 1 / 1", false),
                instance.compile("1 + (1 - 1) * 1", false)
        };
        // 准备一个随机生成器
        final Random random = new Random();
        // 准备一个扫描器
        final Scanner scanner = new Scanner(System.in);
        // 随机选择 10 个表达式 测测看看功能是否正常
        for (int i = 0; i < 10; i++) {
            JvmExpression compile = compiles[random.nextInt(4)];
            // 依次迭代当前表达式的每个操作数
            for (int i1 = 0; i1 < compile.getLength(); i1++) {
                // 开始修改 将操作数修改为 小于等于 100 的数
                compile.setParamNumber(i1, random.nextInt(100));
            }
            // 打印表达式的结果
            Double result = compile.calculation(false).getResult();
            // 判断小数位是否过长 过长的不计算了
            boolean isWireless = String.valueOf(result).split("\\.")[1].length() > 2;
            if (!isWireless) {
                // 打印表达式
                System.out.print(compile.getExpressionStrAndNumber() + " = ");
                try {
                    // 等待用户输入计算结果
                    final String s = scanner.nextLine();
                    // 校验
                    if (Double.parseDouble(s) == result) {
                        System.out.println("解答正确！");
                    } else {
                        System.out.println("解答错误~，正确答案为 = " + result);
                    }
                } catch (NumberFormatException e) {
                    System.out.println("解答错误，您输入的不是一个数字，正确答案为：" + result);
                }
            }
        }
    }
}
```

下面是运行的效果

```
49.0 + (61.0 - 78.0) * 90.0 = -1481
解答正确！
76.0 + (84.0 - 92.0) * 5.0 = 0
解答错误~，正确答案为 = 36.0
50.0 + (96.0 - 15.0) * 5.0 = qqq
解答错误，您输入的不是一个数字，正确答案为：455.0
```

------
***操作记录***
作者：[zhao](https://www.lingyuzhao.top//index.html?search=4 "zhao")
操作时间：2025-07-04 12:57:13 星期五 【时区：UTC 8】
事件描述备注：保存/发布
 中国 天津市 天津
[](如果不需要此记录可以手动删除，每次保存都会自动的追加记录)