三种测试方法#

按”看不看得见代码内部”，PPT 第 51 页把测试方法分成三种：

PPT 第 51、52 页还把”阶段”和”方法”对应了起来，这是这一节最容易考的一条对应关系：

道理很直白：写单元测试的人就是写这个方法的人，代码在自己手里，白盒；越往上（系统测试、验收测试）越像”用户拿过来用”，自然就是黑盒——不需要、也不应该去看内部代码。

那么”看代码”是为了什么？因为真实业务方法往往又长又绕，读一遍都费劲，出了问题更没法靠肉眼看出来：

main 方法测试 vs JUnit 单元测试#

在学 JUnit 之前，很多人是这么”测试”的——写一个带 main 方法的类，把要测的方法挨个调一遍：

PPT 第 54 页把这种方式和 JUnit 单元测试摆在一起做了对比（“VS”）：

“一个失败不影响其他”这一条在实操里差别特别大：main 方法里第 2 个测试抛了异常，第 3、4 个测试就再也不会执行，你还得把前面的注释掉重跑；JUnit 会把所有 @Test 方法都跑一遍，最后一次性告诉你哪些红了。运行结果也就是 PPT 第 55 页那句”测试通过：绿色；测试失败：红色”：

第 1 步：pom.xml 引入 JUnit 依赖#

PPT 第 55 页给的就是这一段：

1
<!-- junit 依赖：JUnit 5 的坐标 -->
2
<dependency>
3
    <groupId>org.junit.jupiter</groupId>     <!-- 组织名：JUnit 5 都是 org.junit.jupiter -->
4
    <artifactId>junit-jupiter</artifactId>  <!-- 模块名：junit-jupiter 是聚合包 -->
5
    <version>5.9.1</version>                <!-- 版本号 -->
6
</dependency>

第 2 步：在 test/java 下建测试类、写测试方法#

前一篇讲过 Maven 的标准目录结构（主程序放 main、测试程序放 test），这里就派上用场了：

1
maven-project01/
2
├── src/main/java/com/itheima/UserService.java        ← 主程序：被测试的业务代码
3
└── src/test/java/com/itheima/UserServiceTest.java     ← 测试程序：测试代码写在这里

被测试的业务代码本身很简单（课程提供的 UserService，两个方法）：

1
package com.itheima;
2

3
import java.time.LocalDate;
4
import java.time.Period;
5
import java.time.format.DateTimeFormatter;
6

7
public class UserService {
8

9
    /**
10
     * 给定一个身份证号, 计算出该用户的年龄
11
     */
12
    public Integer getAge(String idCard){
13
        // 身份证号不合法就直接抛异常（长度必须是 18 位）
14
        if (idCard == null || idCard.length() != 18) {
15
            throw new IllegalArgumentException("无效的身份证号码");
16
        }
17
        // 身份证号第 7~14 位是出生日期（yyyyMMdd）
18
        String birthday = idCard.substring(6, 14);
19
        LocalDate parse = LocalDate.parse(birthday, DateTimeFormatter.ofPattern("yyyyMMdd"));
20
        // 出生日期到今天相差多少年 = 年龄
21
        return Period.between(parse, LocalDate.now()).getYears();
22
    }
23

24
    /**
25
     * 给定一个身份证号, 计算出该用户的性别
26
     */
27
    public String getGender(String idCard){
28
        if (idCard == null || idCard.length() != 18) {
29
            throw new IllegalArgumentException("无效的身份证号码");
30
        }
31
        // 身份证号第 17 位（索引 16）是奇数表示男、偶数表示女
32
        return Integer.parseInt(idCard.substring(16,17)) % 2 == 1 ? "男" : "女";
33
    }
34
}

测试类按 PPT 第 55 页的样子写——类里放测试方法，方法上打 @Test 注解：

1
package com.itheima;
2

3
import org.junit.jupiter.api.Test;
4

5
public class UserServiceTest {
6

7
    @Test
8
    public void testGetAge(){
9
        // 1. 创建要测试的对象
10
        UserService userService = new UserService();
11
        // 2. 调用要测试的方法
12
        Integer age = userService.getAge("100000200010011011");
13
        // 3. 先看看结果是什么（后面学了断言就改成断言）
14
        System.out.println(age);
15
    }
16
}

PPT 第 55 页同时给了两条命名要求，一条是”规范”、一条是”规定”，措辞不一样：

注意：

• JUnit 单元测试类名命名规范为：XxxxxTest【规范】。
• JUnit 单元测试的方法，必须声明为 public void【规定】。

第 3 步：运行单元测试#

运行方式有两种：IDEA 里点测试方法/测试类左边那个绿色三角（或在类里按 Ctrl+Shift+F10），命令行则在项目目录下敲：

1
mvn test        # 跑 src/test/java 下所有测试
2
mvn test -Dtest=UserServiceTest    # 只跑指定的测试类（-Dtest=类名）

PPT 第 55 页最后一句话是判断标准：（测试通过：绿色；测试失败：红色）。

1
[INFO] -------------------------------------------------------
2
[INFO]  T E S T S
3
[INFO] -------------------------------------------------------
4
[INFO] Running 用户信息测试类
5
男
6
25
7
[INFO] Tests run: 7, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.083 s -- in 用户信息测试类
8
[INFO]
9
[INFO] Results:
10
[INFO]
11
[INFO] Tests run: 7, Failures: 0, Errors: 0, Skipped: 0
12
[INFO]
13
[INFO] ------------------------------------------------------------------------
14
[INFO] BUILD SUCCESS
15
[INFO] ------------------------------------------------------------------------

一、知识回顾（读完直接做下面的实践题）#

1. 测试的定义：一种用来促进鉴定软件的正确性、完整性、安全性和质量的过程；阶段划分是单元测试、集成测试、系统测试、验收测试；测试方法有白盒测试、黑盒测试、灰盒测试
2. 四个测试阶段的定义与测试人员：单元测试（对软件的基本组成单位测试，最小测试单位；检验基本组成单位的正确性；开发人员）→ 集成测试（把已通过的单元按设计要求组合成系统/子系统；检查单元之间的协作是否正确；开发人员）→ 系统测试（对集成好的软件系统彻底测试；验证正确性、性能是否满足要求；测试人员）→ 验收测试（交付测试，针对用户需求、业务流程的正式测试；验证是否满足验收标准；客户/需求方）
3. 三种测试方法：白盒测试（清楚软件内部结构、代码逻辑，用于验证代码、逻辑正确性）、黑盒测试（不清楚内部结构，用于验证功能、兼容性等）、灰盒测试（结合两者特点，既关注内部结构又考虑外部表现）
4. 阶段与方法的对应关系：单元测试→白盒测试、集成测试→灰盒测试、系统测试→黑盒测试、验收测试→黑盒测试
5. 单元测试的定义：针对最小的功能单元（方法），编写测试代码对其正确性进行测试
6. JUnit 的定义：最流行的 Java 测试框架之一，提供了一些方便程序进行单元测试的功能，由第三方公司提供（所以要先在 pom.xml 里引依赖：org.junit.jupiter:junit-jupiter，PPT 用 5.9.1）
7. main 方法测试 vs JUnit 单元测试：main 方法的缺点是测试代码与源代码未分开、难维护、一个方法失败影响后面方法、无法自动化测试/得不到报告；JUnit 的优点是代码分开便于维护、可按需自动化测试、自动分析结果产出报告（通过绿色、失败红色）、一个方法失败不影响其它方法
8. 快速入门四步：① 在 pom.xml 中引入 JUnit 依赖 → ② 在 test/java 目录下创建测试类并编写测试方法 → ③ 在方法上声明 @Test 注解 → ④ 运行单元测试（通过：绿色；失败：红色）；命令行是 mvn test
9. 命名规范与存放位置：测试类名 XxxxTest（规范）；测试方法必须声明为 public void（规定）；单元测试代码放 test 目录，写在 main 目录”可以，但是不规范”
10. “运行不报错（绿色）就代表没问题吗？“答案是”并不是”：不写断言时，测试只知道方法没抛异常、不知道结果对不对；本机实测”方法名说要男、实际返回女”的测试依然是 Failures: 0、BUILD SUCCESS

二、动手题#

• 2-1 给项目加上 JUnit 依赖 在练习文件给出的 pom.xml 骨架里，为项目引入 JUnit 5 的依赖：

  1. 组织名用 org.junit.jupiter（JUnit 5 统一是这个）；
  2. 模块名用 junit-jupiter，版本 5.9.1；
  3. 写在”装依赖的容器”标签里，并且用中文注释标出哪行是组织名、哪行是模块名、哪行是版本号。 （练习文件 test_27_junit依赖配置.xml 里已经给了 pom 骨架和写作区。）
  提示（先自己想，实在想不出再点开）

  一级 · 思路：项目要用的第三方 jar 都写在 pom 里一个”容器标签”里；每个 jar 用一个”条目标签”描述，条目里放三行坐标 二级 · 方法：容器是 <dependencies>，条目是 <dependency>；三行是 <groupId> / <artifactId> / <version> 三级 · 骨架：<dependencies><dependency><groupId>____</groupId><artifactId>____</artifactId><version>____</version></dependency></dependencies>

  参考答案（做完再点开）

  1
  <dependencies>
  2
      <!-- junit 依赖：JUnit 5 的坐标 -->
  3
      <dependency>
  4
          <groupId>org.junit.jupiter</groupId>     <!-- 组织名 -->
  5
          <artifactId>junit-jupiter</artifactId>  <!-- 模块名 -->
  6
          <version>5.9.1</version>                <!-- 版本号 -->
  7
      </dependency>
  8
  </dependencies>

  检查点：① <dependencies> 是 <project> 的直接子标签（和 <modelVersion>、<properties> 平级）；② 三行坐标一行都不能少，少一行 Maven 就定位不到 jar；③ 写完记得在 IDEA 里点刷新按钮加载依赖，命令行则相当于每次构建都重新读 pom（这是上一篇讲过的两条注意事项）。本机实测加上这个依赖后 mvn dependency:tree 能看到 org.junit.jupiter:junit-jupiter:jar:5.9.1 这一行。

• 2-2 写第一个 JUnit 测试类 被测的业务类是 UserService，其中有一个方法 public Integer getAge(String idCard)（根据身份证号算年龄）。请：

  1. 在测试程序目录下新建一个测试类（类名按命名规范起）；
  2. 类里写一个测试方法，用于测试 getAge，入参用身份证号 100000200010011011；
  3. 把结果打印出来，方法上别忘了声明能”启动执行”的注解。 （练习文件 test_27_第一个测试类.java 里已经给了写作区。）
  提示（先自己想，实在想不出再点开）

  一级 · 思路：测试类要放对目录（主程序是 main、测试程序是哪一个？）；类名后面加 Test；方法要是 public void；启动执行的注解是哪一个？ 二级 · 方法：目录是 src/test/java；类名 UserServiceTest；方法 public void testGetAge()；注解 @Test（要 import org.junit.jupiter.api.Test） 三级 · 骨架：@Test public void ____(){ Integer age = new UserService().____("____"); System.out.println(age); }

  参考答案（做完再点开）

  1
  package com.itheima;
  2
  
  3
  import org.junit.jupiter.api.Test;
  4
  
  5
  public class UserServiceTest {
  6
  
  7
      @Test
  8
      public void testGetAge(){
  9
          // 1. 创建要测试的对象
  10
          UserService userService = new UserService();
  11
          // 2. 调用要测试的方法（传入身份证号）
  12
          Integer age = userService.getAge("100000200010011011");
  13
          // 3. 打印结果（还没学断言，先打印看结果）
  14
          System.out.println(age);
  15
      }
  16
  }

  显示更多显示更少

  文件应该出现在 src/test/java/com/itheima/UserServiceTest.java（和主程序同包名，但目录是 test 不是 main）。本机实测（Maven 3.9.14 / JDK 17）：mvn test 输出里会有 Tests run: 1, Failures: 0, Errors: 0，以及打印出来的 25（出生日期 2000-10-01，到 2026-09-29 为 25 周岁）。

• 2-3 写一个”故意不写断言”的测试方法，并解释它为什么是绿的 再写一个测试方法（比如测 getGender），要求：

  1. 方法名写成 testGenderShouldBeMale（方法名里表明”应该是男”）；
  2. 传入的身份证号请故意选一个实际返回”女”的（第 17 位是偶数，比如 100000200010011022）；
  3. 方法里只打印结果、不写任何断言，然后运行它；
  4. 在文件末尾的注释里回答：这个”和方法名矛盾”的测试为什么还是绿色的？怎么改才让它真正检查结果？ （练习文件 test_27_不写断言的测试.java 里已经给了写作区。）
  提示（先自己想，实在想不出再点开）

  一级 · 思路：JUnit 判断一个测试”失败”，靠的是”方法抛异常了”；不写断言就等于什么也没检查 二级 · 方法：断言是 JUnit 提供的辅助方法（Assertions.assertEquals(预期, 实际, 提示信息)）；不写它，测试只知道”没报错” 三级 · 骨架：打印用 System.out.println(____)；真正检查结果要用 Assertions.____("男", gender)

  参考答案（做完再点开）

  1
  package com.itheima;
  2
  
  3
  import org.junit.jupiter.api.DisplayName;
  4
  import org.junit.jupiter.api.Test;
  5
  
  6
  public class UserServiceTest {
  7
  
  8
      @Test
  9
      @DisplayName("测试：这个身份证号的性别应该是『男』（方法名这么说的）")
  10
      public void testGenderShouldBeMale(){
  11
          UserService userService = new UserService();
  12
          // 身份证第 17 位是 2（偶数）→ 实际返回"女"
  13
          String gender = userService.getGender("100000200010011022");
  14
          System.out.println("方法名说应该是男，实际返回的是：" + gender);
  15
          // 不写断言 → 测试依然是绿的
  16
      }
  17
  }

  显示更多显示更少

  两个问题的答案：

  1. 为什么还是绿的：JUnit 判断失败的唯一标准是”测试方法抛出了异常”。没有断言，方法就只是创建对象、调方法、打印，正常结束 → Failures: 0、BUILD SUCCESS。本机实测（Maven 3.9.14 / JDK 17）输出正是：测试方法名说性别应该是男，实际返回的是：女 + Tests run: 1, Failures: 0, Errors: 0。
  2. 怎么改：加断言，把它变成”结果和预期不一致就报错”。例如 Assertions.assertEquals("男", gender, "性别获取有问题");——这样它会立刻变成红色，并在报告里给出 expected: <男> but was: <女>（断言的完整用法见下一篇）。

三、综合题#

• 3-1 给 UserService 写一个完整的测试类 把这一篇的东西串起来做一遍。被测的 UserService 有两个业务方法：getAge(String idCard) 和 getGender(String idCard)。要求：

  1. 在 src/test/java/com/itheima/ 下新建测试类，类名符合命名规范（XxxxTest）；
  2. 给 getAge 和 getGender 各写一个测试方法，方法名用 test + 业务方法名，声明成 public void，并且都打上启动执行的注解；
  3. 两个方法里都用身份证号 100000200010011011 调用业务方法，并把结果打印出来；
  4. 在 IDLE/命令行里运行整个测试类（不是只运行一个方法），把输出里 Tests run: x, Failures: x 和最后一行抄下来；
  5. 在文件末尾的注释里回答三个问题：① 这个测试类为什么必须放在 test 目录而不是 main 目录？② 如果类名写成 TestUserService（不是 XxxxTest）会有什么问题？③ 如果方法写成 static void testGetAge() 能不能跑起来，为什么？ （练习文件 test_27_综合_UserService测试类.java 里按这 5 步给了写作区。）

  涉及知识点

  知识点	在这里的应用
  单元测试的粒度	一个业务方法对应一个测试方法
  项目结构	主程序 src/main/java、测试程序 src/test/java
  JUnit 快速入门	@Test 注解 + mvn test（或 IDEA 里的绿色三角）运行
  命名规范	类 XxxxTest（规范）、方法 public void（规定）
  绿色 ≠ 没问题	只用 System.out.println 打印时，测试永远是绿的

  提示（先自己想，实在想不出再点开）

  一级 · 思路：把”四步快速入门”按顺序做一遍——依赖已经在 pom 里了，剩下三件事：建对目录、起对名字、加对注解；打印只是过渡手段，重点是让测试真的跑起来 二级 · 方法：测试类放 src/test/java/com/itheima/；类名 UserServiceTest；两个方法 public void testGetAge() / public void testGetGender()，各加 @Test；运行用 IDEA 的绿色三角或命令行 mvn test 三级 · 骨架：public class UserService____Test { @Test public void ____(){ ... } }

  参考答案（做完再点开）

  3-1

  1
  package com.itheima;
  2
  
  3
  import org.junit.jupiter.api.Test;
  4
  
  5
  /**
  6
   * 测试类：类名规范是 XxxxTest
  7
   */
  8
  public class UserServiceTest {
  9
  
  10
      @Test
  11
      public void testGetAge(){
  12
          UserService userService = new UserService();
  13
          Integer age = userService.getAge("100000200010011011");
  14
          System.out.println("年龄：" + age);
  15
      }
  16
  
  17
      @Test
  18
      public void testGetGender(){
  19
          UserService userService = new UserService();
  20
          String gender = userService.getGender("100000200010011011");
  21
          System.out.println("性别：" + gender);
  22
      }
  23
  }

  显示更多显示更少

  4. 运行结果（本机实测，Maven 3.9.14 / JDK 17，mvn test）：

     1
     [INFO] Running com.itheima.UserServiceTest
     2
     性别：男
     3
     年龄：25
     4
     [INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.045 s -- in com.itheima.UserServiceTest
     5
     [INFO] Results:
     6
     [INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0
     7
     [INFO] BUILD SUCCESS

     关键看两行：Tests run: 2, Failures: 0, Errors: 0 和最后的 BUILD SUCCESS（打印顺序不一定和方法的书写顺序一致，JUnit 不保证方法执行顺序——本机这次先打印的是”性别”再是”年龄”）。
  5. 三个问题： ① 为什么放 test 目录：Maven 的标准结构规定主程序放 main、测试程序放 test，两者分开才能”便于维护”（JUnit 的优点之一）；而且测试代码不应该参与打包上线，写在 main 里会混进主程序、还可能被打进 jar。PPT 第 65 页对”能不能写在 main 目录”的回答是”可以，但是不规范”。 ② 类名不叫 XxxxTest 的问题：违反命名规范，团队里别人一眼看不出这是测试类，某些构建工具/插件按 *Test 模式找测试时还可能根本不会执行它（测试写了等于没写）。 ③ 方法写成 static void 能不能跑：不能。JUnit 的规定是测试方法必须声明为 public void 的实例方法，static 方法不符合规范，会被当成普通方法跳过（同理，private、带返回值的方法也都不会被执行）。

这一篇先把”测试跑起来”这件事做完，下一篇补上断言（让测试真的能判断对错）和常见注解（参数化测试、@DisplayName、@BeforeEach/@AfterEach 的执行时机）。