16 Java（junit）测试+Assert（断言测试）、枚举类、注解、javac编译和javap反编译命令、常量

文章目录

前言
- javac命令：将.java文件编译成其对应的.class字节码文件
- javap命令：将.class字节码文件反编译回字节码文件
一、Java测试
二、枚举类
三、注解
四、常量（final修饰）

前言

在开始本节前，先来介绍一个java里面的编译和反编译命令

javac命令：将.java文件编译成其对应的.class字节码文件

建议结合枚举一起看这个，下面就用下面这个枚举里面的例子来演示

package cn.hjblogs.Test;
/**
 * @author JUHE
 * @version 1.0
 */
public class EnumerationDemo {
   
    public static void main(String[] args) {
   
        /*
        - 需求：
        - 1) 声明Week枚举类，其中包含星期一至星期日的定义：MONDAY ，TUESDAY, WEDNESDAY， THURSDAY，FRIDAY, SATURDAY, SUNDAY；
        - 2) 使用values 返回所有的枚举数组,并遍历
        */
        Week[] weeks = Week.values();
        for (Week week : weeks) {
   
            System.out.println(week);   // 星期一 星期二 星期三 星期四 星期五 星期六 星期日
        }
    }
}

enum Week {
   
    MONDAY("星期一"), TUESDAY("星期二"), WEDNESDAY("星期三"),
    THURSDAY("星期四"), FRIDAY("星期五"), SATURDAY("星期六"), SUNDAY("星期日");
    private String name;

    private Week(String name) {
   
        this.name = name;
    }

    @Override
    public String toString() {
   
        return this.name;
    }
}

将这个java文件粘贴到一个空文件夹里面，然后在cmd使用javac命令进行编译
javac EnumerationDemo.java
在这里插入图片描述
可以看到编译出来了两个class字节码文件。

javap命令：将.class字节码文件反编译回字节码文件

【注】：这个反编译回的.java代码能够看到一些隐式继承的信息
下面我们将上面的Week.class反编译回去看看
javap Week.class
在这里插入图片描述
你看，从这个反编译后的结果看，很明显enum关键字隐式继承了java.lang.Enum这个类。所以反编译往往能看到一些隐藏信息。

一、Java测试

1 测试的概念

测试分类
- 黑盒测试：一般就是用户干的那种测试，有一个界面给点来点去，看看是不是想要的结果。
  input -->黑盒–>output, 中间是什么样不知道，只关系最后的输出结果对不对。
  不需要写代码，给输入值，看程序是否能够输出期望的值。
- 白盒测试：就是经典的程序员debug这种类型测试。
  需要写代码的。关注程序具体的执行流程。
  我们今天讲的测试也是这个，看看经典的白盒测试流程是什么样子的。
Junit测试：Junit就是Java中的测试的一套流程。下面我们会着重讲这个Junit测试的步骤是什么样子的。

2 先来看看我们之前是怎么测试的

先写一个计算机的类（里面有加法add和减法sub两个方法要测试）

package cn.hjblogs.junit;

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

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

之前我们是这么测试的：

package cn.hjblogs.junit;
public class Test {
   
    public static void main(String[] args) {
   
        Calculator calculator = new Calculator();
        // 测试add方法
        int result1 = calculator.add(1, 2);
        System.out.println(result1);

        // 测试sub方法
        int result2 = calculator.sub(1, 2);
        System.out.println(result2);
    }
}

这么测试我只能说很low，而且有时候这样测试有时候很不方便，特别是测试的方法间有依赖关系，你还得将前面的代码注释了测试，很麻烦。下面我们学习Junit测试就能解决这个问题了

3 Junit测试 + Assert（断言测试）

参考视频1
参考视频2

Junit使用: 白盒测试
步骤:
- 1.定义一个测试类(测试用例)
  （建议）测试类名: 被测试的类名Test ，例如 CalculatorTest
  （建议）包名:xxx.xxx.xx.test，例如 cn.itcast.test
- 2.定义测试方法:可以独立运行
  （建议）方法名:test测试的方法名，例如 testAdd()
  （建议）返回值: void
  （建议）参数列表:空参
- 4.导入junit依赖环境(需要网上找一个junit的jar包手动导入)
- 3.给方法加@Test注解
判定结果:
- 红色: 失败
- 绿色: 成功
- 一般我们会使用断言操作来处理结果
  Assert.assertEquals(期望的结果，运算的结果)
junit中的三个注解
- @Test: 加上这个注解的方法就可以成为一个独立运行的方法，右边侧边栏就会出现一个绿色的可点击的运行按钮
- @Before：加上这个注解的方法就会在所有测试方法在执行之前都会执行该方法（修饰的方法会在测试方法之前被自动执行）
  - 初始化方法(不是必须；函数名可以自定义，但是要加上@Before注解)
  - 用于资源申请，所有测试方法在执行之前都会执行该方法
  - 使用场景：一些测试的重复代码，可以放在这里，就不用每个测试方法都写一遍
- @After：加上这个注解的方法就会在所有测试方法在执行之后都会执行该方法（修饰的方法会在测试方法执行之后自动被执行。）
  - 结束方法，结束之后执行（不是必须；函数名可以自定义，但是要加上@After注解）
  - 用于资源释放，所有测试方法执行完之后都会执行该方法
  - 使用场景：比如说io流的关闭，数据库的关闭等，都可以放在这里

【注】：@Before、@After修饰的方法就算中间测试的方法测试中出现了异常，这两个方法都是会执行完毕。

下面我们来看看上面的例子怎么用上面流程进行Junit测试+ Assert（断言测试）

package cn.hjblogs.Test;


import cn.hjblogs.junit.Calculator;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class CalculatorTest {
   


    /**
     * 初始化方法(不是必须；函数名可以自定义，但是要加上@Before注解)
     * 用于资源申请，所有测试方法在执行之前都会执行该方法
     * 使用场景：一些测试的重复代码，可以放在这里，就不用每个测试方法都写一遍
     */
    @Before
    public void init(){
   
        System.out.println("init...");
    }

    /**
     * 销毁方法，结束之后执行（不是必须；函数名可以自定义，但是要加上@After注解）
     * 用于资源释放，所有测试方法执行完之后都会执行该方法
     * 使用场景：比如说io流的关闭，数据库的关闭等，都可以放在这里
     */
    @After
    public void close(){
   
        System.out.println("close...");
    }




    /**
     * 测试add方法
     */
    @Test
    public void test_add(){
   
        System.out.println("test_add...");
        Calculator c = new Calculator();
        int result = c.add(1, 2);
        // System.out.println(result);   // 我们一般不打印，因为打印的最终结果也有可能是错的，我们采用断言

        // 断言 我断言这个结果是3
        // 如果结果是3，那么测试通过，否则测试不通过
        // 第一个参数是期望值，第二个参数是实际值
        Assert.assertEquals(3, result);
    }

    /**
     * 测试sub方法
     */
    @Test
    public void test_sub(){
   
        System.out.println("test_sub...");
        Calculator c = new Calculator();
        int result = c.sub(1, 2);
        // System.out.println(result);
        // 断言 我断言这个结果是-1
        // 如果结果是-1，那么测试通过，否则测试不通过
        // 第一个参数是期望值，第二个参数是实际值
        Assert.assertEquals(-1, result);
    }
}

这样就可以在每个测试函数的左边有一个绿色的运行按钮可以直接运行就很方便了。

二、枚举类

1 枚举类的引入

看下面这个需求

创建Season对象有如下特点
- 1.季节的值是有限的几个值(spring,summer, autumn, winter)
- 2.只读，不需要修改。
  常规的创建类对象描述上面的季节就像下面那样：

package cn.hjblogs.Test;

/**
 * @author JUHE
 * @version 1.0
 */
public class EnumerationDemo {
   
    public static void main(String[] args) {
   
        Season spring = new Season("春天", "春暖花开");
        Season summer = new Season("夏天", "夏日炎炎");
        Season winter = new Season("冬天", "冰天雪地");
        Season autumn = new Season("秋天", "秋高气爽");
        // Season other = new Season("红天", "XXXXX");  // 不能创建其他季节对象
        // autumn.setName("XXX");  // 秋天就是秋天，不能改变
        // autumn.setDesc("XXXXX"); // 秋天就是秋天，不能改变
        // 因为对于季节而已，他的对象(具体值)，是固定的四个，不会有更多
        // 这个常规设计类的思路，不能体现季节是固定的四个对象
        // 因此，这样的设计不好===>就需要采用枚举类[枚:一个一个举:例举，即把具体的对象一个一个例举出来的类

        System.out.println(spring.getName() + "：" + spring.getDesc());
        System.out.println(summer.getName() + "：" + summer.getDesc());
        System.out.println(autumn.getName() + "：" + autumn.getDesc());
        System.out.println(winter.getName() + "：" + winter.getDesc());

    }
}

class Season {
   
    private String name;
    private String desc;  // 描述

    public Season(String name, String desc) {
   
        this