12、Junit测试、反射、注解

Java

JavaSE

发布日期: 2022-05-28

更新日期: 2022-06-01

文章字数: 2.9k

阅读时长: 12 分

阅读次数:

Junit 单元测试

测试分类：
1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。
2. 白盒测试：需要写代码的。关注程序具体的执行流程。
Junit 使用：白盒测试

白盒测试步骤

定义一个测试类(测试用例)

建议：

测试类名：被测试的类名 Test 如：CalculatorTest
包名：xxx.xxx.xx.test 如：cn.itcast.test

定义测试方法：可以独立运行

建议：

方法名：test 测试的方法名 testAdd()
返回值：void
参数列表：空参

给方法加@Test
导入 junit 依赖环境

判定结果

红色：失败
绿色：成功

一般我们会使用断言操作来处理结果：
Assert.assertEquals(期望的结果,运算的结果);
补充：

@Before

修饰的方法会在测试方法之前被自动执行

@After

修饰的方法会在测试方法执行之后自动被执行

示例：
com/xjt/junit_test.Calculator.java

package com.xjt.junit_test;

/**
 * 计算器类
 */
public class Calculator {
    /**
     * 加法
     * @param a
     * @param b
     * @return
     */
    public int add (int a , int b){
        //int i = 3/0;
        return a + b;
    }

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

com/xjt/test/CalculatorTest.java

package com.xjt.test;

import com.xjt.junit_test.Calculator;
import org.junit.After;				//导入junit的jar包，存到项目lib目录下
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class CalculatorTest {
    /**
     * 初始化方法：
     *  用于资源申请，所有测试方法在执行之前都会先执行该方法
     */
    @Before
    public void init(){
        System.out.println("init...");
    }

    /**
     * 释放资源方法：
     *  在所有测试方法执行完后，都会自动执行该方法
     */
    @After
    public void close(){
        System.out.println("close...");
    }

    /**
     * 测试add方法
     */
    @Test
    public void testAdd(){
        // System.out.println("我被执行了");
        //1.创建计算器对象
        System.out.println("testAdd...");
        Calculator c  = new Calculator();
        //2.调用add方法
        int result = c.add(1, 2);
        //System.out.println(result);

        //3.断言  我断言这个结果是3
        Assert.assertEquals(4,result);

    }

    @Test
    public void testSub(){
        //1.创建计算器对象
        Calculator c  = new Calculator();
        int result = c.sub(1, 2);
        System.out.println("testSub....");
        Assert.assertEquals(-1,result);
    }
}

反射

反射被称为框架设计的灵魂

框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
反射：将类的各个组成部分封装为其他对象，这就是反射机制

好处：

可以在程序运行过程中，操作这些对象(如 IDEA 编辑器能通过对象.方法，就是运行过程中通过反射获取对象方法的)。
可以解耦，提高程序的可扩展性。

java 代码三个阶段

获取 Class 对象

`Class.forName("全类名")`

将字节码文件加载进内存，返回 Class 对象
多用于配置文件，将类名定义在配置文件中。读取文件，加载类

`类名.class`：

通过类名的属性 class 获取
多用于参数的传递

`对象.getClass()`：

getClass()方法在 Object 类中定义着。
多用于对象的获取字节码的方式

结论：

同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的 Class 对象都是同一个。

public static void main(String[] args) throws Exception {
    //1.Class.forName("全类名")
    Class cls1 = Class.forName("cn.itcast.domain.Person");
    System.out.println(cls1);

    //2.类名.class
    Class cls2 = Person.class;
    System.out.println(cls2);

    //3.对象.getClass()
    Person p = new Person();
    Class cls3 = p.getClass();
    System.out.println(cls3);

    //== 比较三个对象
    System.out.println(cls1 == cls2);	//true
    System.out.println(cls1 == cls3);	//true

    Class c = Student.class;
    System.out.println(c == cls1);	//false
}

Class 对象功能

获取成员变量(们)

Field[] getFields() ：获取所有 public 修饰的成员变量
Field getField(String name) 获取指定名称的 public 修饰的成员变量
Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
Field getDeclaredField(String name)

**
Field：成员变量

操作：
1. 设置值
  - void set(Object obj, Object value)
2. 获取值
  - get(Object obj)
3. 忽略访问权限修饰符的安全检查
  - setAccessible(true):暴力反射

获取构造方法(们)

Constructor<?>[] getConstructors()
Constructor getConstructor(类<?>… parameterTypes)
Constructor getDeclaredConstructor(类<?>… parameterTypes)
Constructor<?>[] getDeclaredConstructors()

**
Constructor:构造方法

创建对象：
- T newInstance(Object… initargs)
- 如果使用空参数构造方法创建对象，操作可以简化：Class 对象的 newInstance 方法

获取成员方法(们)

Method[] getMethods()
Method getMethod(String name, 类<?>… parameterTypes)
Method[] getDeclaredMethods()
Method getDeclaredMethod(String name, 类<?>… parameterTypes)

**
Method：方法对象

执行方法：
- Object invoke(Object obj, Object… args)
获取方法名称：
- String getName:获取方法名

获取全类名

String getName()

public static void main(String[] args) throws Exception {

    //0.获取Person的Class对象
    Class personClass = Person.class;
    /*
             1. 获取成员变量们
                 * Field[] getFields()
                 * Field getField(String name)

                 * Field[] getDeclaredFields()
                 * Field getDeclaredField(String name)

         */
    //1.Field[] getFields()获取所有public修饰的成员变量
    Field[] fields = personClass.getFields();
    for (Field field : fields) {
        System.out.println(field);
    }

    System.out.println("------------");
    //2.Field getField(String name)
    Field a = personClass.getField("a");
    //获取成员变量a 的值
    Person p = new Person();
    Object value = a.get(p);
    System.out.println(value);
    //设置a的值
    a.set(p,"张三");
    System.out.println(p);

    System.out.println("===================");

    //Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
    Field[] declaredFields = personClass.getDeclaredFields();
    for (Field declaredField : declaredFields) {
        System.out.println(declaredField);
    }
    //Field getDeclaredField(String name)
    Field d = personClass.getDeclaredField("d");
    //忽略访问权限修饰符的安全检查
    d.setAccessible(true);//暴力反射
    Object value2 = d.get(p);
    System.out.println(value2);
}

示例 2：

public static void main(String[] args) throws Exception {
    //0.获取Person的Class对象
    Class personClass = Person.class;

    //Constructor<T> getConstructor(类<?>... parameterTypes)
    Constructor constructor = personClass.getConstructor(String.class, int.class);
    System.out.println(constructor);
    //创建对象
    Object person = constructor.newInstance("张三", 23);
    System.out.println(person);

    System.out.println("----------");

    Constructor constructor1 = personClass.getConstructor();
    System.out.println(constructor1);
    //创建对象
    Object person1 = constructor1.newInstance();
    System.out.println(person1);

    Object o = personClass.newInstance();
    System.out.println(o);
    //constructor1.setAccessible(true);
}

示例 3：

public static void main(String[] args) throws Exception {

    //0.获取Person的Class对象
    Class personClass = Person.class;
    /*
          3. 获取成员方法们：
             * Method[] getMethods()
             * Method getMethod(String name, 类<?>... parameterTypes)

             * Method[] getDeclaredMethods()
             * Method getDeclaredMethod(String name, 类<?>... parameterTypes)
         */
    //获取指定名称的方法
    Method eat_method = personClass.getMethod("eat");
    Person p = new Person();
    //执行方法
    eat_method.invoke(p);


    Method eat_method2 = personClass.getMethod("eat", String.class);
    //执行方法
    eat_method2.invoke(p,"饭");

    System.out.println("-----------------");

    //获取所有public修饰的方法
    Method[] methods = personClass.getMethods();
    for (Method method : methods) {
        System.out.println(method);
        String name = method.getName();
        System.out.println(name);
        //method.setAccessible(true);
    }

    //获取类名
    String className = personClass.getName();
    System.out.println(className);//cn.itcast.domain.Person
}

案例：
需求：写一个”框架”，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法

实现：
1. 配置文件
2. 反射
步骤：
1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
2. 在程序中加载读取配置文件
3. 使用反射技术来加载类文件进内存
4. 创建对象
5. 执行方法

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        //可以创建任意类的对象，可以执行任意方法
        /*
            前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
         */
        /*  Person p = new Person();
        p.eat();*/
        /*
        Student stu = new Student();
        stu.sleep();*/

        //1.加载配置文件
        //1.1创建Properties对象
        Properties pro = new Properties();
        //1.2加载配置文件，转换为一个集合
        //1.2.1获取class目录下的配置文件
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        pro.load(is);

        //2.获取配置文件中定义的数据
        String className = pro.getProperty("className");
        String methodName = pro.getProperty("methodName");


        //3.加载该类进内存
        Class cls = Class.forName(className);
        //4.创建对象
        Object obj = cls.newInstance();
        //5.获取方法对象
        Method method = cls.getMethod(methodName);
        //6.执行方法
        method.invoke(obj);
    }
}

注解

概念：

说明程序的，给计算机看的，@Override

注释：

用文字描述程序的，给程序员看的，Java 单行注释 // 多行注释/**/

定义：

注解（Annotation），也叫元数据。一种代码级别的说明。它是 JDK1.5 及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。

概念描述：

JDK1.5 之后的新特性
说明程序的
使用注解：@注解名称

JDK 中预定义的注解

@Override：

检测被该注解标注的方法是否是继承自父类(接口)的

@Deprecated：

该注解标注的内容，表示已过时

@SuppressWarnings：

压制警告
一般传递参数 all，放在整个类上面，那么该类里的所有方法都不会警告（IDEA 右侧有一个黄线） @SuppressWarnings(“all”)public class ReflectTest {}

@SuppressWarnings("all")
public class AnnoDemo2 {
    @Override
    public String toString() {
        return super.toString();
    }

    @Deprecated
    public void show1(){
        //有缺陷被遗弃的方法
    }

    public void show2(){
        //替代show1方法
    }

    public void demo(){
        show1();
        Date date = new Date();		//Date中很多方法都被遗弃了，调用时会有一条删减线
    }
}

自定义注解

格式

元注解
public @interface 注解名称{
	属性列表;
}

注解本质

怎么查看注解本质？

源文件 xxx.java(去掉第一行依赖包) —>编译(javac xxx.java) —>生成(xxx.class) —>反编译(javap xxx.class) —>生成反编译 java 文件(xxx.java)

注解本质上就是一个接口，该接口默认继承 Annotation 接口
public interface MyAnno extends java.lang.annotation.Annotation {}
属性：也就是接口中的抽象方法；

要求

属性的返回值类型只有下列取值
- 基本数据类型
- String 字符串
- 枚举 enum
- 注解
- 以上类型的数组
定义了属性，在使用时需要给属性赋值
- 如果定义属性时，使用 default 关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
- 如果只有一个属性需要赋值，并且属性的名称是 value，则 value 可以省略，直接定义值即可。
- 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略

MyAnno.java

public @interface MyAnno {
    int value();
    Person per();
    MyAnno2 anno2();
    String[] strs();
     /*String name() default "张三";*/
     /*String show2();

     Person per();
     MyAnno2 anno2();

     String[] strs();*/
}

Person.java 是一个枚举

public enum Person {
    P1,P2;
}

Worker.java

@MyAnno(value=12,per = Person.P1,anno2 = @MyAnno2,strs="bbb")
@MyAnno3
public class Worker {
    @MyAnno3
    public String name = "aaa";
    @MyAnno3
    public void show(){
    }
}

元注解

用于描述注解的注解

@Target

描述注解能够作用的位置
- ElementType 取值：
- TYPE：可以作用于类上
- METHOD：可以作用于方法上
- FIELD：可以作用于成员变量上
@Retention

描述注解被保留的阶段
- @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到 class 字节码文件中，并被 JVM 读取到(一般我们自己定义的注解都是这个)
@Documented

描述注解是否被抽取到 api 文档中
@Inherited

描述注解是否被子类继承

案例：从注解中读取配置信息，代替从配置文件中读配置

package cn.itcast.annotation;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * 框架类
 */
@Pro(className = "cn.itcast.annotation.Demo1",methodName = "show")
public class ReflectTest {
    public static void main(String[] args) throws Exception {
        /*
            前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
         */
        //1.解析注解
        //1.1获取该类的字节码文件对象
        Class<ReflectTest> reflectTestClass = ReflectTest.class;
        //2.获取上边的注解对象
        //其实就是在内存中生成了一个该注解接口的子类实现对象
        /*

            public class ProImpl implements Pro{
                public String className(){
                    return "cn.itcast.annotation.Demo1";
                }
                public String methodName(){
                    return "show";
                }

            }
 */
        Pro an = reflectTestClass.getAnnotation(Pro.class);
        //3.调用注解对象中定义的抽象方法，获取返回值
        String className = an.className();
        String methodName = an.methodName();
        System.out.println(className);
        System.out.println(methodName);

        //3.加载该类进内存
        Class cls = Class.forName(className);
        //4.创建对象
        Object obj = cls.newInstance();
        //5.获取方法对象
        Method method = cls.getMethod(methodName);
        //6.执行方法
        method.invoke(obj);
    }
}

Pro.java

package cn.itcast.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 描述需要执行的类名，和方法名
 */

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Pro {
    String className();
    String methodName();
}

CoderXiong

http://bfd2018.github.io/2022/05/28/javase/12-junit-ce-shi-fan-she-zhu-jie/

本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 CoderXiong !

Java

10、函数式接口

2022-05-28 JavaSE

Java

11、Stream流、方法引用

2022-05-28 JavaSE

Java

12、Junit测试、反射、注解

Junit 单元测试

白盒测试步骤

判定结果

反射

java 代码三个阶段

获取 Class 对象

Class.forName("全类名")

类名.class：

对象.getClass()：

Class 对象功能

获取成员变量(们)

获取构造方法(们)

获取成员方法(们)

获取全类名

注解

JDK 中预定义的注解

自定义注解

格式

注解本质

要求

元注解

你的赏识是我前进的动力

`Class.forName("全类名")`

`类名.class`：

`对象.getClass()`：