JavaSE大神进阶篇（第八期）：全网最详细最通俗易懂的Java中Junit注解知识点汇总

是真的小外套

648人浏览 · 2026-05-01 16:11:03

是真的小外套 · 2026-05-01 16:11:03 发布

Junit单元测试

引入
- 【1】软件测试的目的：
  - 是在规定的条件下对程序进行操作, 以发现程序错误, 衡量软件质量, 并对其是否能满足设计要求进行评估的过程
- 【2】测试分类：
  - （1）黑盒测试
    - 软件的黑盒测试意味着测试要在软件的接口处进行
    - 这种方法是把测试对象看做一个黑盒子, 测试人员完全不考虑程序内部的逻辑结构和内部特性, 只依据程序的需求规格说明书, 检查程序的功能是否符合它的功能说明。因此黑盒测试又叫功能测试
  - （2）白盒测试 (Junit属于白盒测试)
    - 软件的白盒测试是对软件的过程性细节做细致的检查
    - 这种方法是把测试对象看做一个打开的盒子, 它允许测试人员利用程序内部的逻辑结构及有关信息, 设计或选择测试用例, 对程序的所有逻辑路径进行测试,通过在不同点检查程序状态, 确定实际状态是否与预期的状态一致。因此白盒测试又称为结构测试
- 图解

没有Junit的情况下如何测试

没有使用Junit的缺点：
- 测试一定走main方法，是程序的入口，main方法的格式必须不能写错
- 要是在同一个main方法中测试的话，那么不需要测试的东西必须注释掉
- 测试逻辑如果分开的话，需要定义多个测试类，麻烦
- 业务逻辑和测试代码，都混淆了

代码

package com.xxx.calculator;

public class Calculator {
    //加法：
    public int add(int a, int b) {
        return a+b;
    }

    //减法：
    public int sub(int a, int b) {
        return a-b;
    }
}

public class Test {
    public static void main(String[] args) {
        //测试加法
        Calculator cal = new Calculator();
        int result = cal.add(10, 20);
        System.out.println(result);
        //测试减法
        /*
        int result = cal.sub(30, 10);
        System.out.println(result);
        */
    }
}

public class Test02 {
    public static void main(String[] args) {
        Calculator cal = new Calculator();
        //测试减法：
        int result = cal.sub(30, 10);
        System.out.println(result);
    }
}

Junit的使用

【1】一般测试和业务做一个分离，分离为不同的包
- 建议起名：公司域名倒着写+test
- 以后测试类就单独放在这个包下
【2】测试类的名字
- ****Test --> 见名知意
【3】测试方法的定义
- 这个方法可以独立运行，不依托于main方法
  - 名字：testAdd(), testSub() 见名知意
  - 参数：无参
  - 返回值：void
【4】测试方法定义完以后，不能直接就独立运行了必须要在方法前加入一个注解：
- @Test
【5】导入Junit的依赖的环境：

【6】代码：

package com.xxx.test;

import com.xxx.calculator.Calculator;
import org.junit.Test;

public class CalculatorTest {
    //测试add方法
    @Test
    public void testAdd() {
        System.out.println("测试add方法");        
        Calculator cal = new Calculator();        
        int result = cal.add(10, 30);        
        System.out.println(result);
    }

    //测试sub方法
    @Test
    public void testSub(){
        System.out.println("测试sub方法");        
        Calculator cal = new Calculator();        
        int result = cal.sub(10, 30);        
        System.out.println(result);
    }
}

【7】判定结果：
- 绿色：正常结果
- 红色：出现异常

【8】即使出现绿色效果，也不意味着你的测试就通过了，因为代码中逻辑也可能出现问题，这种情况怎么解决呢？

加入断言

package com.xxx.test;

import com.xxx.calculator.Calculator;
import org.junit.Assert;
import org.junit.Test;

public class CalculatorTest {
    //测试add方法
    @Test
    public void testAdd(){
        System.out.println("测试add方法");
        Calculator cal = new Calculator();
        int result = cal.add(10, 30);
        //System.out.println(result); --> 程序的运行结果可以不关注
        //加入断言：预测一下结果，判断一下我预测的结果和 实际的结果是否一致：
        Assert.assertEquals(40, result); //第一个参数：预测结果  第二个参数：实际结果
    }

    //测试sub方法
    @Test
    public void testSub(){
        System.out.println("测试sub方法");        
        Calculator cal = new Calculator();        
        int result = cal.sub(10, 30);        
        System.out.println(result);
    }
}

实验结果

在这里插入图片描述

`@Before`与`@After`

@Before:
- 某一个方法中，加入了@Before注解以后，那么这个方法中的功能会在测试方法执行前先执行
- 一般会在@Beforer修饰的那个方法中加入：加入一些申请资源的代码：申请数据库资源，申请IO资源，申请网络资源
@After:
- 某一个方法中，加入了@After注解以后，那么这个方法中的功能会在测试方法执行后先执行
- 一般会在@After修饰的那个方法中加入：加入释放资源的代码：释放数据库资源，释放IO资源，释放网络资源

代码：

package com.xxx.test;

import com.xxx.calculator.Calculator;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class CalculatorTest {
    @Before
    public void init(){
        System.out.println("方法执行开始了。。。");
    }
    @After
    public void close(){
        System.out.println("方法执行结束了。。。");
    }
    //测试add方法
    @Test
    public void testAdd(){
        System.out.println("测试add方法");        
        Calculator cal = new Calculator();        
        int result = cal.add(10, 30);
        //System.out.println(result); --> 程序的运行结果可以不关注
        //加入断言：预测一下结果，判断一下我预测的结果和 实际的结果是否一致：
        Assert.assertEquals(40, result); //第一个参数：预测结果  第二个参数：实际结果
    }

    //测试sub方法
    @Test
    public void testSub(){
        System.out.println("测试sub方法");        
        Calculator cal = new Calculator();        
        int result = cal.sub(10, 30);        
        System.out.println(result);
    }
}

注解

引入
- 【1】历史：
  - JDK5.0 新增 --> 注解（Annotation）, 也叫元数据
- 【2】什么是注解？
  - 注解其实就是代码里的特殊标记
  - 通过使用注解, 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息
  - 代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署
  - 使用注解时要在其前面增加@符号,并把该注解当成一个修饰符使用。用于修饰它支持的程序元素
- 【3】注解的重要性：
  - Annotation可以像修饰符一样被使用，可用于修饰包，类，构造器,方法，成员变量,参数，局部变量的声明，这些信息被保存在Annotation的"name=value"对中
  - 在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等
  - 在JavaEE/ArIdroid中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置等
  - 未来的开发模式都是基于注解的，JPA(java的持久化API)是基于注解的，Spring2.5以前都是基于注解的，Hibernate3.x以后也是基于注解的，现在的Struts2有一部分也是基于注解的了，注解是一种趋势，一定程度上可以说：框架 = 注解 + 反射 + 设计模式

注解的使用实例

Junit的注解

代码：

package com.xxx.test;

import com.msb.calculator.Calculator;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class CalculatorTest {
    @Before
    public void init(){
        System.out.println("方法执行开始了。。。");
    }

    @After
    public void close(){
        System.out.println("方法执行结束了。。。");
    }

    @Test
    public void testAdd(){
        System.out.println("测试add方法");        
        Calculator cal = new Calculator();        
        int result = cal.add(10, 30);
        Assert.assertEquals(40, result); //第一个参数：预测结果  第二个参数：实际结果
    }
}

文档相关的注解

说明注释允许你在程序中嵌入关于程序的信息, 你可以使用 javadoc 工具软件来生成信息，并输出到 HTML 文件中
说明注释使你更加方便的记录你的程序信息
文档注解我们一般使用在文档注释中，配合 javadoc 工具
javadoc 工具软件识别以下标签：
- 其中注意：
  - @param @return @exception 这三个标记都是只用于方法的
  - @param 的格式要求: @param 形参名形参类型形参说明
  - @return的格式要求: @return 返回值类型返回值说明，如果方法的返回值类型是void就不能
  - @exception的格式要求: @exception 异常类型异常说明
  - @param 和 @exception 可以并列多个
代码

package com.xxx.anno;

/**
 * @author : msb-zhaoss
 * @version : 1.0
 */
public class Person {
    /**
    * 下面是eat方法，实现了 xxx 功能
    * @param num1 就餐人数
    * @param num2 点了几个菜
    */
    public void eat(int num1,int num2){}

    /**
     * @param age 年龄
     * @return int
     * @exception RuntimeException 当年龄过大的时候
     * @exception IndexOutOfBoundsException 当年龄过小的时候
     * @see Student
     */
    public int sleep(int age){
        new Student();
        if(age > 100){
            throw new RuntimeException();
        }
        if(age < 0){
            throw new IndexOutOfBoundsException();
        }
        return 10;
    }
}

IDEA中的javaDoc使用：

在这里插入图片描述

防止乱码：

在这里插入图片描述

JDK内置的3个注解

@Override 限定重写父类方法，该注解只能用于方法

public class Person {
    public void eat(){
        System.out.println("父类eat..");
    }
}

public class Student extends Person {
    /*
    @Override的作用：限定重写的方法，只要重写方法有问题，就有错误提示
    */
    @Override
    public void eat(){
        System.out.println("子类eat..");
    }
}

@Deprecated 用于表示所修饰的元素 (类,方法，构造器，属性等) 已过时。通常是因为所修饰的结构危险或存在更好的选择

public class Student extends Person {
    /*
    @Override的作用：限定重写的方法，只要重写方法有问题，就有错误提示
    */
    @Override
    public void eat(){
        System.out.println("子类eat..");
    }
    /*
    在方法前加入@Deprecated, 这个方法就会变成一个废弃方法 / 过期方法 / 过时方法
    */

    @Deprecated
    public void study(){
        System.out.println("学习。。");
    }
}

在这里插入图片描述

@SuppressWarnings 抑制编译器警告

public class Test02 {
    public static void main(String[] args) {
        @SuppressWarnings("unused")
        int age = 10;
        int num = 10;
        System.out.println(num);
        @SuppressWarnings({"unused","rwatypes"})
        ArrayList al = new ArrayList();
    }
}

实现替代配置文件功能的注解

在servlet3.0之前的配置：

package com.xxxx.servlet;

import javax.servlet.*;
import java.io.IOException;

public class HelloServlet implements Servlet {
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {}

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("service方法被调用了...");
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {}
}

<?xml version="1.0" encoding="UTF-8"?> 
<web-app xmlns = "http://xmlns.jcp.org/xml/ns/javaee" 
        xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation = "http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
        version="4.0"> 
    <!--配置Servlet-->
    <!--配置Servlet的信息--> 
    <servlet>
        <servlet-name>HelloServlet</servlet-name> 
        <servlet-class>com.bjsxt.servlet.HelloServlet</servlet-class> 
    </servlet>
    <!--配置Servlet的映射路径--> 
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name> 
        <!--http://localhost:8080/01-hello-servlet/hello-->
        <url-pattern>hello</url-pattern>
    </servlet-mapping>
</web-app>

在servlet3.0之后使用注解：替代配置文件

package com.xxxx.servlet;

import javax.servlet.*;
import java.io.IOException;

@WebServlet("/hello")
public class HelloServlet implements Servlet {
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {}

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    /**
     * 用于提供服务, 接收请求, 处理响应
     * @param servletRequest
     * @param servletResponse
     * @throws ServletException
     * @throws IOException
     */

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("service方法被调用了...");
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {}
}

自定义注解
- 【1】自定义注解使用很少，一般情况下都是用现成的注解
- 【2】如何自定义注解：
- 【3】注解的内部：
- 【4】使用注解：
  - （1）使用注解的话，如果你定义了配置参数，就必须给配置参数进行赋值操作：
```
@MyAnnotation(value={"abc","def","hij"})
public class Person {}
```
  - （2）如果只有一个参数，并且这个参数的名字为value的话，那么value=可以省略不写
```
@MyAnnotation({"abc","def","hij"})
public class Person {}
```
  - （3）如果你给配置参数设置默认的值了，那么使用的时候可以无需传值：
```
public @interface MyAnnotation2 {
    String value() default "abc";
}
```
  - 使用：
```
@MyAnnotation2
@MyAnnotation({"abc","def","hij"})
public class Person {}
```
  - （4）一个注解的内部是可以不定义配置参数的：
```
public @interface MyAnnotation3 {}
```
    - 内部没有定义配置参数的注解 --> 可以叫做标记
```
public @interface Override {}
```
    - 内部定义配置参数的注解 --> 元数据
- 【5】注解的使用：
  - 现在只学习注解的大致技能点，具体怎么应用后面慢慢学习
元注解
- 概述
  - 元注解是用于修饰其它注解的注解
  - JDK5.0提供了四种元注解：Retention, Target, Documented, Inherited
- Retention
  - 概述
    - 用于修饰注解，用于指定修饰的那个注解的生命周期
    - Rentention包含一个RetentionPolicy枚举类型的成员变量，使用@Rentention时必须为该value成员变量指定值
    - RetentionPolicy.SOURCE --> 在源文件中有效(即源文件保留)，编译器直接丢弃这种策略的注释，在.class文件中不会保留注解信息
  - 案例
  - 反编译查看字节码文件：发现字节码文件中没有MyAnnotation这个注解
```
package com.xxx.anno03;

public class Person {
        public Person() {}
}
```
    - RetentionPolicy.CLASS在class文件中有效 (即class保留)，保留在.class文件中，但是当运行Java程序时，他就不会继续加载了，不会保留在内存中， JVM不会保留注解。如果注解没有加Retention元注解，那么相当于默认的注解就是这种状态
  - 案例
```
@Retention(RetentionPolicy.CLASS)
public @interface MyAnnotation {
    String[] value();
}
```
```
@MyAnnotation({"abc", "def", "hij"})
public class Person {}
```
  - 反编译看字节码文件，字节码文件中带有MyAnnotation注解：
```
package com.xxx.anno3;

@MyAunotation({"abc", "def", "hij"})
public class Person {
  public Person(){}
}
```
  - RetentionPolicy.RUNTIME在运行时有效 (即运行时保留) , 当运行 Java 程序时，JVM会保留注释，加载在内存中了，那么程序可以通过反射获取该注释
- Target
  - 概述
    - 用于修饰注解的注解，用于指定被修饰的注解能用于修饰哪些程序元素。@Target也包含一个名为value的成员变量
  - 案例
```
@Target({TYPE,CONSTRUCTOR,METHOD})
public @interface MyAnnotation4 {}
```
  - 使用
```
@MyAunotation4
public class Student {
  @MyAnnotation4
  int age;
  @MyAnnotation4
  public Student() {}
  @MyAnnotation4
  public void eat() {}
}
```
- Documented（很少）
  - 概念
    - 用于指定被该元注解修饰的注解类将被javadoc工具提取成文档。默认情况下，javadoc是不包括注解的，但是加上了这个注解生成的文档中就会带着注解了
  - 案例
    - 如果：Documented注解修饰了Deprecated注解
  - 那么Deprecated注解就会在javadoc提取的时候，提取到API中
- Inherited（极少）
  - 概念
    - 被它修饰的Annotation将具有继承性。如果某个类使用了被@Inherited修饰的Annotation, 则其子类将自动具有该注解
  - 案例
    - 注解 --> 如果MyAnno注解使用了@Inherited之后，就具备了继承性，那么相当于子类Student也使用了这个MyAnno
```
@Inherited
public @interface MyAnno {}
```
  - 父类
```
@MyAnno
public class Person {}
```
  - 子类
```
public class Student extends Person {}
```

枚举

引入

【1】数学：枚举法
- 1<x<4
- 2<y<5
- 求x+y=6
- 枚举法：一枚一枚的列举出来。前提：有限，确定
【2】在java中，类的对象是有限个，确定的。这个类我们可以定义为枚举类
- 举例
  - 星期：一二三四五六日
  - 性别：男女
  - 季节：春夏秋冬

【3】自定义枚举类：（JDK1.5之前自定义枚举类）

package com.msb.enum01;

public class Season {
  //属性：
  private final String seasonName; //季节名字
  private final String seasonDesc; //季节描述
  //利用构造器对属性进行赋值操作：
  //构造器私有化，外界不能调用这个构造器，只能Season内部自己调用
  private Season(String seasonName, String seasonDesc) {
    this.seasonName = seasonName;
    this.seasonDesc = seasonDesc;
  }

  //提供枚举类的有限的  确定的对象
  public static final Season SPRING = new Season("春天","春暖花开");
  public static final Season SUMMER = new Season("夏天","烈日炎炎");
  public static final Season AUTUMN = new Season("秋天","硕果累累");
  public static final Season WINTER = new Season("冬天","冰天雪地");

  //额外因素
  public String getSeasonName() {
    return seasonName;
  }

  public String getSeasonDesc() {
    return seasonDesc;
  }

  //toString();
  @Override
  public String toString() {
    return "Season{" + "seasonName='" + seasonName + '\'' + ", seasonDesc='" + seasonDesc + '\'' + '}';
  }
}

测试类

public class TestSeason {
  public static void main(String[] args) {
    Season summer = Season.SUMMER;
    System.out.println(summer/*.toString()*/);
    System.out.println(summer.getSeasonName());
  }
}

JDK1.5之后使用enum关键字来创建枚举类

JDK1.5以后使用enum关键字创建枚举类

变为下面的枚举类

package com.xxx.enum02;

public enum Season {
  //提供枚举类的有限的  确定的对象：---> enum枚举类要求对象（常量）必须放在最开始位置
  //多个对象之间用`,`进行连接，最后一个对象后面用;结束
  SPRING("春天","春暖花开"),
  SUMMER("夏天","烈日炎炎"),
  AUTUMN("秋天","硕果累累"),
  WINTER("冬天","冰天雪地");
  //属性
  private final String seasonName ; //季节名字
  private final String seasonDesc ; //季节描述
  //利用构造器对属性进行赋值操作
  //构造器私有化，外界不能调用这个构造器，只能Season内部自己调用
  private Season(String seasonName, String seasonDesc) {
    this.seasonName = seasonName;
    this.seasonDesc = seasonDesc;
  }

  //额外因素
  public String getSeasonName() {
    return seasonName;
  }

  public String getSeasonDesc() {
    return seasonDesc;
  }

  //toString();

  @Override
  public String toString() {
    return "Season{" + "seasonName='" + seasonName + '\'' + ", seasonDesc='" + seasonDesc + '\'' + '}';
  }
}

使用枚举类

public class TestSeason {
  public static void main(String[] args) {
    Season winter = Season.WINTER;
    System.out.println(winter);
    //enum关键字对应的枚举类的上层父类是：java.lang.Enum
    //但是我们自定义的枚举类的上层父类：Object
    System.out.println(Season.class.getSuperclass().getName()); //java.lang.Enum
  }
}

在源码中经常看到别人定义的枚举类形态
```
public enum Season {
  SPRING,
  SUMMER,
  AUTUMN,
  WINTER;
}
```
- 为什么这么简单
  - 因为这个枚举类底层没有属性，构造器，toString，get方法都删掉不写了
  - 然后案例来说应该写为：SPRING() 现在连（）可以省略就变成 SPRING
  - 看到的形态就剩：常量名（对象名）

案例

Thread中的枚举类：State

public enum State {
  /**
   * 线程的 NEW（新建）状态，对象已创建，但尚未调用 start() 方法
   */
  NEW,

  /**
   * 可运行线程的线程状态
   * 处于 runnable 状态的线程正在 Java 虚拟机中执行
   * 但它可能正在等待来自操作系统的其他资源
   * 比如处理器（CPU）
   */
  RUNNABLE,

  /**
   * 线程被阻塞并等待监视器锁的线程状态
   * 处于 blocked 状态的线程正在等待一个监视器锁
   * 以便进入一个 synchronized 同步块/方法
   * 或者在调用 Object.wait() 之后，重新进入一个 synchronized 同步块/方法
   */
  BLOCKED,

  /**
   * 等待线程的线程状态
   * 一个线程因调用以下方法之一而进入等待状态: 
   * Object.wait() 不带超时
   * Thread.join() 不带超时
   * LockSupport.park()
   * 处于等待状态的线程正在等待另一个线程执行特定操作
   * 例如，调了 Object.wait() 的线程在等别人调 notify()
   * 调了 Thread.join() 的线程在等目标线程终止
   */
  WAITING,

  /**
   * 具有指定等待时间的等待线程的线程状态
   * 线程因调用以下带正等待时间参数的方法之一而进入计时等待状态: 
   * Thread.sleep(毫秒)
   * Object.wait(毫秒) 带超时
   * Thread.join(毫秒) 带超时
   * LockSupport.parkNanos(纳秒)
   * LockSupport.parkUntil(截止时间)
   */
  TIMED_WAITING,

  /**
   * 终止线程的线程状态
   * 该线程已经完成执行
   */
  TERMINATED;
}

Enum类的常用方法

代码展示

package com.xxx.enum03;

public class TestSeason {
  public static void main(String[] args) {
    //用enum关键字创建的Season枚举类上面的父类是：java.lang.Enum
    //常用方法子类Season可以直接拿过来使用：
    //toString(); ---> 获取对象的名字
    Season autumn = Season.AUTUMN;
    System.out.println(autumn/*.toString()*/); //AUTUMN

    System.out.println("--------------------");
    //values:返回枚举类对象的数组
    Season[] values = Season.values();
    for(Season s:values){
      System.out.println(s/*.toString()*/);
    }

    System.out.println("--------------------");
    //valueOf：通过对象名字获取这个枚举对象
    //注意：对象的名字必须传正确，否则抛出异常
    Season autumn1 = Season.valueOf("AUTUMN");
    System.out.println(autumn1);
  }
}

枚举类实现接口

定义一个接口

public interface TestInterface {
  void show();
}

枚举类实现接口，并且重写show方法

public enum Season implements TestInterface {
  SPRING,    
  SUMMER,    
  AUTUMN,    
  WINTER;

  @Override
  public void show() {
    System.out.println("这是Season....");
  }
}

测试类

public class Test {
  public static void main(String[] args) {
    Season autumn = Season.AUTUMN;
    autumn.show();
    Season summer = Season.SUMMER;
    summer.show();
  }
}

上面发现所有的枚举对象，调用这个show方法的时候走的都是同一个方法，结果都一样

但是现在我想要：不同的对象调用的show方法也不同

package com.xxx.enum04;

import java.sql.SQLOutput;

public enum Season implements TestInterface {
  SPRING{
    @Override
    public void show() {
      System.out.println("这是春天。。。");
    }
  }, 
  SUMMER{
    @Override
    public void show() {
      ystem.out.println("这是夏天。。");
    }
  },
  AUTUMN{
    @Override
    public void show() {
      System.out.println("这是秋天");
    }
  },
  WINTER{
    @Override
    public void show() {
      System.out.println("这是冬天");
    }
  };

  /*
  @Override
  public void show() {
    System.out.println("这是Season....");
  }
  */
}

测试类

public class Test {
  public static void main(String[] args) {
    Season autumn = Season.AUTUMN;
    autumn.show();
    Season summer = Season.SUMMER;
    summer.show();
  }
}

实际应用

代码展示

package com.xxx.enum05;

public class Person {
  //属性
  private int age;
  private String name;
  private Gender sex;

  public int getAge() {
    return age;
  }

  public void setAge(int age) {        
    this.age = age;
  }

  public String getName() {        
    return name;
  }

  public void setName(String name) {        
    this.name = name;
  }

  public Gender getSex() {
    return sex;
  }

  public void setSex(Gender sex) {
    this.sex = sex;
  }

  @Override
  public String toString() {
    return "Person{" + "age=" + age + ", name='" + name + '\'' + ", sex='" + sex + '\'' + '}';
  }
}

public enum Gender {
  男,
  女;
}

public class Test {
  public static void main(String[] args) {
    Person p = new Person();
    p.setAge(19);
    p.setName("lili");
    p.setSex(Gender.男); //传入枚举类Gender的对象： --> 在入口处对参数进行了限制
    System.out.println(p);
  }
}

还可以通过枚举结合switch处理：

public class Test02 {
  public static void main(String[] args) {
    Gender sex = Gender.男;
    //switch后面的（）中可以传入枚举类型
    //switch后面的（）:int,short,byte,char,String, 枚举
    switch (sex){
      case 女:
        System.out.println("是个女孩");
        break;
        case 男:
          System.out.println("是个男孩");
          break;
    }
  }
}

亚马逊云科技技术品牌专区

更多推荐

算术胶子与自指宇宙：AGI本质的科学推论辨析——从椭圆曲线、Sha群、多世界诠释通往高阶文明的可能性（前沿理论框架猜想）

亚马逊云科技技术品牌专区

网络安全防护体系建设实践分享

它需要战略层面的重视、持续的资源投入，以及技术、管理、人与流程的深度融合。未来，网络安全防护体系的建设将更加强调“左移”（安全融入开发早期）与“右伸”（延伸至供应链安全），并更加依赖云原生安全、人工智能（AI）赋能的安全分析、威胁狩猎等新技术与新方法，向自适应安全架构演进。通过部署全流量镜像分析系统、网络威胁检测（NTD）及高级威胁检测（APT）平台，结合威胁情报（TI），对网络内部东西向流量与南

亚马逊云科技技术品牌专区

53.1.智能投喂器-硬件定时-基于STM32嵌入式物联网单片机软硬件毕业生系统设计【硬件+APP+云平台】

亚马逊云科技技术品牌专区

所有评论(0)

查看更多评论

是真的小外套

@2401_88349202

已为社区贡献13条内容

JavaSE大神进阶篇（第八期）：全网最详细最通俗易懂的Java中Junit注解知识点汇总

是真的小外套

Junit单元测试

引入

【1】软件测试的目的：

是在规定的条件下对程序进行操作, 以发现程序错误, 衡量软件质量, 并对其是否能满足设计要求进行评估的过程

【2】测试分类：

（1）黑盒测试

软件的黑盒测试意味着测试要在软件的接口处进行

这种方法是把测试对象看做一个黑盒子, 测试人员完全不考虑程序内部的逻辑结构和内部特性, 只依据程序的需求规格说明书, 检查程序的功能是否符合它的功能说明。因此黑盒测试又叫功能测试

（2）白盒测试 (Junit属于白盒测试)

软件的白盒测试是对软件的过程性细节做细致的检查

图解

没有Junit的情况下如何测试

没有使用Junit的缺点：

测试一定走main方法，是程序的入口，main方法的格式必须不能写错

要是在同一个main方法中测试的话，那么不需要测试的东西必须注释掉

测试逻辑如果分开的话，需要定义多个测试类，麻烦

业务逻辑和测试代码，都混淆了

代码

Junit的使用

【1】一般测试和业务做一个分离，分离为不同的包

建议起名：公司域名倒着写+test

以后测试类就单独放在这个包下

【2】测试类的名字

****Test --> 见名知意

【3】测试方法的定义

这个方法可以独立运行，不依托于main方法

名字：testAdd(), testSub() 见名知意

参数：无参

返回值：void

【4】测试方法定义完以后，不能直接就独立运行了必须要在方法前加入一个注解：

@Test

【5】导入Junit的依赖的环境：

【6】代码：

【7】判定结果：

绿色：正常结果

红色：出现异常

【8】即使出现绿色效果，也不意味着你的测试就通过了，因为代码中逻辑也可能出现问题，这种情况怎么解决呢？

加入断言

实验结果

@Before与@After

@Before:

某一个方法中，加入了@Before注解以后，那么这个方法中的功能会在测试方法执行前先执行

一般会在@Beforer修饰的那个方法中加入：加入一些申请资源的代码：申请数据库资源，申请IO资源，申请网络资源

@After:

某一个方法中，加入了@After注解以后，那么这个方法中的功能会在测试方法执行后先执行

一般会在@After修饰的那个方法中加入：加入释放资源的代码：释放数据库资源，释放IO资源，释放网络资源

代码：

注解

引入

【1】历史：

JDK5.0 新增 --> 注解（Annotation）, 也叫元数据

【2】什么是注解？

注解其实就是代码里的特殊标记

通过使用注解, 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息

代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署

使用注解时要在其前面增加@符号,并把该注解当成一个修饰符使用。用于修饰它支持的程序元素

【3】注解的重要性：

Annotation可以像修饰符一样被使用，可用于修饰包，类，构造器,方法，成员变量,参数，局部变量的声明，这些信息被保存在Annotation的"name=value"对中

在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等

在JavaEE/ArIdroid中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置等

注解的使用实例

Junit的注解

代码：

文档相关的注解

说明注释 允许你在程序中嵌入关于程序的信息, 你可以使用 javadoc 工具软件来生成信息，并输出到 HTML 文件中

说明注释 使你更加方便的记录你的程序信息

文档注解 我们一般使用在文档注释中，配合 javadoc 工具

javadoc 工具软件识别以下标签：

其中注意：

@param @return @exception 这三个标记都是只用于方法的

@param 的格式要求: @param 形参名 形参类型 形参说明

@return的格式要求: @return 返回值类型返回值说明，如果方法的返回值类型是void就不能

@exception的格式要求: @exception 异常类型异常说明

@param 和 @exception 可以并列多个

代码

IDEA中的javaDoc使用：

防止乱码：

JDK内置的3个注解

`****Test --> 见名知意`

名字：`testAdd(), testSub()` 见名知意

`@Before`与`@After`

`@Before`:

某一个方法中，加入了`@Before`注解以后，那么这个方法中的功能会在测试方法执行前先执行

一般会在`@Beforer`修饰的那个方法中加入：加入一些申请资源的代码：申请数据库资源，申请IO资源，申请网络资源

`@After`:

某一个方法中，加入了`@After`注解以后，那么这个方法中的功能会在测试方法执行后先执行

一般会在`@After`修饰的那个方法中加入：加入释放资源的代码：释放数据库资源，释放IO资源，释放网络资源

`Annotation`可以像修饰符一样被使用，可用于修饰包，类，构造器,方法，成员变量,参数，局部变量的声明，这些信息被保存在`Annotation`的`"name=value"`对中

在`JavaSE`中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等

在`JavaEE/ArIdroid`中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替`JavaEE`旧版中所遗留的繁冗代码和XML配置等

说明注释允许你在程序中嵌入关于程序的信息, 你可以使用 `javadoc` 工具软件来生成信息，并输出到 `HTML` 文件中

说明注释使你更加方便的记录你的程序信息

文档注解我们一般使用在文档注释中，配合 `javadoc` 工具

`javadoc` 工具软件识别以下标签：

`@param @return @exception 这三个标记都是只用于方法的`

`@param 的格式要求: @param 形参名形参类型形参说明`

`@return的格式要求: @return 返回值类型返回值说明，如果方法的返回值类型是void就不能`

`@exception的格式要求: @exception 异常类型异常说明`

`@param 和 @exception 可以并列多个`

`@Override` 限定重写父类方法，该注解只能用于方法

`@Deprecated` 用于表示所修饰的元素 (类,方法，构造器，属性等) 已过时。通常是因为所修饰的结构危险或存在更好的选择

`@SuppressWarnings` 抑制编译器警告

（2）如果只有一个参数，并且这个参数的名字为`value`的话，那么`value=`可以省略不写

`内部没有定义配置参数的注解 --> 可以叫做标记`

`内部定义配置参数的注解 --> 元数据`

现在只学习注解的大致技能点，具体怎么应用后面慢慢学习

`Rentention`包含一个`RetentionPolicy`枚举类型的成员变量，使用`@Rentention`时必须为该value成员变量指定值

`RetentionPolicy.SOURCE` --> 在源文件中有效(即源文件保留)，编译器直接丢弃这种策略的注释，在`.class`文件中不会保留注解信息

反编译查看字节码文件：发现字节码文件中没有`MyAnnotation`这个注解

反编译看字节码文件，字节码文件中带有`MyAnnotation`注解：

`RetentionPolicy.RUNTIME`在运行时有效 (即运行时保留) , 当运行 `Java` 程序时，`JVM`会保留注释，加载在内存中了，那么程序可以通过反射获取该注释

用于修饰注解的注解，用于指定被修饰的注解能用于修饰哪些程序元素。`@Target`也包含一个名为`value`的成员变量

用于指定被该元注解修饰的注解类将被`javadoc`工具提取成文档。默认情况下，`javadoc`是不包括注解的，但是加上了这个注解生成的文档中就会带着注解了

那么`Deprecated`注解就会在`javadoc`提取的时候，提取到`API`中

被它修饰的`Annotation`将具有继承性。如果某个类使用了被`@Inherited`修饰的`Annotation`, 则其子类将自动具有该注解

注解 --> 如果`MyAnno`注解使用了`@Inherited`之后，就具备了继承性，那么相当于子类`Student`也使用了这个`MyAnno`

`1<x<4`

`2<y<5`

`求x+y=6`