JavaSE - 12、Junit测试、反射、注解 - 《CoderXiong 的博客 - 学习笔记整理》

Junit单元测试
- 白盒测试步骤
- 判定结果
反射

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() ```java 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：
```java
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. 执行方法 ```java 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);
}

}

<a name="WenOx"></a>
## 注解
概念：
> 说明程序的，给计算机看的，@Override
注释：
> 用文字描述程序的，给程序员看的，Java单行注释 //   多行注释/**/
定义：
> 注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。
概念描述：
- JDK1.5之后的新特性
- 说明程序的
- 使用注解：@注解名称
<a name="zZkE0"></a>
### JDK中预定义的注解
`@Override`：
> 检测被该注解标注的方法是否是继承自父类(接口)的
`@Deprecated`：
> 该注解标注的内容，表示已过时
`@SuppressWarnings`：
> 压制警告
一般传递参数all，放在整个类上面，那么该类里的所有方法都不会警告（IDEA右侧有一个黄线） @SuppressWarnings("all")public class ReflectTest {}
![image.png](https://cdn.nlark.com/yuque/0/2020/png/1559629/1605411164426-8b709425-c0eb-4782-a111-315a04a72a6b.png#align=left&display=inline&height=463&margin=%5Bobject%20Object%5D&name=image.png&originHeight=463&originWidth=990&size=143136&status=done&style=none&width=990)
```java
@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 的博客 - 学习笔记整理

12、Junit测试、反射、注解

Junit单元测试

白盒测试步骤

判定结果

反射

java代码三个阶段

获取Class对象

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

`类名.class`：

`对象.getClass()`：

Class对象功能

获取成员变量(们)

获取构造方法(们)

获取成员方法(们)

获取全类名

自定义注解

格式

注解本质

要求

元注解

12、Junit测试、反射、注解

Junit单元测试

白盒测试步骤

判定结果

反射

java代码三个阶段

获取Class对象

Class.forName("全类名")

类名.class：

对象.getClass()：

Class对象功能

获取成员变量(们)

获取构造方法(们)

获取成员方法(们)

获取全类名

自定义注解

格式

注解本质

要求

元注解

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

`类名.class`：

`对象.getClass()`：