Java：Junit单元测试、反射、注解

内容

1. Junit单元测试
2. 反射
3. 注解

---

Junit单元测试

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

  • 步骤：

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

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

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

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

    3. 给方法加@Test

    4. 导入junit依赖环境

  • 判定结果：

    • 红色：失败
    • 绿色：成功
    • 一般我们会使用断言操作来处理结果
      • Assert.assertEquals(期望的结果,运算的结果);

  • 补充：

    • @Before:
      • 修饰的方法会在测试方法之前被自动执行
    • @After:
      • 修饰的方法会在测试方法执行之后自动被执行

---

测试类

/**
 * 计算器类
 */

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;
    }
}

Junit测试

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

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

    @Test
    public void testAdd(){
        System.out.println("testAdd...");
        Calculator c = new Calculator();
        int result = c.add(1,2);
        Assert.assertEquals(3,result);
    }

    @Test
    public void testSub(){
        System.out.println("testSub...");
        Calculator c = new Calculator();
        int result = c.sub(1,2);
        Assert.assertEquals(-1,result);
    }
}

---

反射：框架设计的灵魂

• 框架：半成品软件。可以在框架的基础上进行软件开发，简化编码

• 反射：将类的各个组成部分封装为其他对象，这就是反射机制

  • 好处：
  1. 可以在程序运行过程中，操作这些对象
  2. 可以解耦，提高程序的可拓展性

• 获取Class对象的方式:

  1. Class.forName(“全类名”)：将字节码文件加载进内存，返回class对象
     多用于配置文件，将类名定义在配置文件中。读取文件，加载类。
  2. 类名.class：通过类名的属性class获取
     多用于参数的传递
  3. 对象。getClass()：getClass()方法在object类中定义着
     多用于对象的获取字节码的方式

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

Class对象功能：

• 获取功能
  1.获取成员变量们

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

  2.获取构造方法

  • Constructor<?>[] getConstructors()
  • Constructor getConstructors(类<?>…parameterTypes)
  • Constructor getDeclaredConstructor(类<?>…parameterTypes)
  • Constructor<?>[] getDeclaredCOnstructor()

  3.获取成员方法：

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

  4.获取全类名

  • String getName()

Field：成员变量

* 操作：
	1. 设置值
		* void set(Object obj, Object value)  
	2. 获取值
		* get(Object obj) 

	3. 忽略访问权限修饰符的安全检查
		* setAccessible(true):暴力反射

Constructor:构造方法

* 创建对象：
	* T newInstance(Object... initargs)  

	* 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

Method: 方法对象

* 执行方法：
	* Object invoke(Object obj, Object... args)  

* 获取方法名称：
	* String getName:获取方法名

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

/**
 * 框架演示类
 *      可以创建任意类的对象，可以执行任意方法
 * 前提：
 *      不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
 *
 * 1. 加载配置文件
 * 2. 获取配置文件中定义的数据
 * 3. 加载该类进内存
 * 4. 创建对象
 * 5. 获取方法对象
 * 6. 执行方法
 */

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

        // 创建Properties对象
        Properties pro = new Properties();
        ClassLoader classLoader = _05ReflectTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        pro.load(is);

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

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

注解

• 概念：说明程序的，给计算机看。
• 注释：用文字描述程序的，给程序员看。
• 定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。
• 作用分类：
  1. 编写文档：通过代码里标识的注解生成文档（生成文档doc注解）
  2. 代码分析：通过代码里标识的注解对代码进行分析（使用反射）
  3. 编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查（override）
• JDK中预定义的一些注解
  1. @Override：检测被该注解标注的方法是否是继承自父类（接口）的
  2. @Deprecated：该注解标注的内容，标识已过时
  3. @SupperssWarnings：压制警告
  一般传递参数all @SupperssWarings(“all”)

自定义注解

格式:
	元注解
	public @interface 注解名称{
		属性列表;
	}
本质:
	注解本质上就是一个接口，该接口默认继承Annotation接口
	public interface MyAnhno extends java.lang.annotation.Annotation{} 
属性：接口中的抽象方法
	要求：
		1. 属性的返回值类型有下列取值
			- 基本数据类型
			- String
			- 枚举
			- 注解
			- 以上类型的数组
		2. 定义了属性，在使用时需要给属性复制
			- 如果定义属性是，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值
			- 如果只有一个属性需要赋值，并且属性的名称时value，则value可以省略，直接定义值即可
			- 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略

元注解

用于描述注解的注解
@Target：描述注解能够作用的位置
	- ElementType取值：
		- TYPE：可以作用于类上
		- METHOD：可以作用于方法上
		- FIELD：可以作用于成员变量上	
@Retention：描述注解别保留的阶段
	- Rentention(RetentionPolicy.RUNTIME)：当前被描述的注解，会·保留到class字节码文件中，并被JVM读取到
@Documented：描述注解是否被抽取到api文档中
@Inherited：描述注解是否被子类继承

自定义注解

import java.lang.annotation.*;

/**
 * 元注解：用于描述注解的注解
 * @Target  ：描述注解能够作用的位置
 * @Rentention  ： 描述注解被保留的阶段
 * @Documented  ：描述注解是否被抽取到api文档中
 * @Inherited   ：描述注解是否被子类继承
 */
//@Target(value = {ElementType.TYPE})     //  表示该MyAnno3注解只能作用于类上
@Target(value = {ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyAnno3 {
}

ProAnno注解

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 ProAnno {
    String className();
    String methodName();
}

用注解完成的框架演示类

import java.lang.reflect.Method;

/**
 * 框架演示类
 *      可以创建任意类的对象，可以执行任意方法
 * 前提：
 *      不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
 *
 * 1. 加载配置文件
 * 2. 获取配置文件中定义的数据
 * 3. 加载该类进内存
 * 4. 创建对象
 * 5. 获取方法对象
 * 6. 执行方法
 */

@ProAnno(className = "Improve.Annotation.Demo1",methodName = "show")
public class ReflectTest {
    public static void main(String[] args) throws Exception {
        // 1. 解析注解
        // 1.1 获取该类的字节码文件对象
        Class<ReflectTest> reflectTestClass = ReflectTest.class;
        // 2. 获取上边的注解对象
        ProAnno anno = reflectTestClass.getAnnotation(ProAnno.class);
        // 3. 调用注解对象中定义的抽象方法，获取返回值
        String className = anno.className();
        String methodName = anno.methodName();
        System.out.println(className);
        System.out.println(methodName);

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