08Junit、反射、注解

最新推荐文章于 2025-06-30 16:14:24 发布

hd小龙

最新推荐文章于 2025-06-30 16:14:24 发布

阅读量133

点赞数

CC 4.0 BY-SA版权

分类专栏： java 文章标签： 08Junit、反射、注解

本文链接：https://blog.youkuaiyun.com/qq_43353277/article/details/86104203

java 专栏收录该内容

23 篇文章

订阅专栏

本文深入解析JUnit单元测试的使用方法，包括测试用例的编写与断言操作；详细阐述Java反射机制，演示如何通过反射操作类的成员变量、构造方法及执行方法；并介绍注解的基本概念，展示其在类、方法上的应用实例。

Junit、反射、注解

一、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:
    - 修饰的方法会在测试方法执行之后自动被执行

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

 //测试add方法
    public int add (int a , int b){
        //int i = 3/0;
        return a - b;
    }
@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(3,result);

}

二、反射

获取Class对象的方式：

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

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

Class对象功能：

获取功能：

获取成员变量们

Field[] getFields() ：获取所有public修饰的成员变量
Field getField(String name)   获取指定名称的 public修饰的成员变量

Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
Field getDeclaredField(String name)

获取构造方法们

Constructor<?>[] getConstructors()  
Constructor<T> getConstructor(类<?>... parameterTypes)  

Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  
Constructor<?>[] getDeclaredConstructors()

获取成员方法们

Method[] getMethods()
Method getMethod(String name, 类<?>... parameterTypes)  

Method[] getDeclaredMethods()
Method getDeclaredMethod(String name, 类<?>... parameterTypes)

获取全类名

String getName()

需要反射的类：

public class Person {
    private String name;
    private int age;
    public String a;
    protected String b;
    String c;
    private String d;
    
    public Person() {
    }
    public Person(String name, int age) {

        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
    public void eat(){
        System.out.println("eat...");
    }
    public void eat(String food){
        System.out.println("eat..."+food);
    }
}

成员变量

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

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

//0.获取Person的Class对象
Class personClass = Person.class;

//1.Field[] getFields()获取所有public修饰的成员变量
Field[] fields = personClass.getFields();
for (Field field : fields) {
    System.out.println(field);//public java.lang.String itcast.domain.Person.a
}
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);//null
//设置a的值
a.set(p,"张三");
System.out.println(p);//Person{name='null', age=0, a='张三', b='null', c='null', d='null'}

构造方法

Constructor:构造方法
	* 创建对象：
		* T newInstance(Object... initargs)  

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

//0.获取Person的Class对象
Class personClass = Person.class;
Constructor constructor = personClass.getConstructor(String.class, int.class);
System.out.println(constructor);//public itcast.domain.Person(java.lang.String,int)
//创建对象
Object person = constructor.newInstance("张三", 23);
System.out.println(person);//Person{name='张三', age=23, a='null', b='null', c='null', d='null'}

方法对象

Method：方法对象
	* 执行方法：
		* Object invoke(Object obj, Object... args)  
	* 获取方法名称：
		* String getName:获取方法名

//0.获取Person的Class对象
Class personClass = Person.class;
//获取指定名称的方法
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("-----------------");
//获取类名
String className = personClass.getName();
System.out.println(className);//cn.itcast.domain.Person

练习：

className=demo02.Act
methodName=cat

public class Act {
    private String name;

    public void cat(){
        System.out.println("cat无参构造！");
    }
}

public static void main(String[] args) throws Exception{
    //1.加载配置文件
    //1.1创建Properties对象
    Properties pro = new Properties();
    //1.2加载配置文件，转换为一个集合
    //1.2.1获取class目录下的配置文件
    ClassLoader classLoader = Reflect.class.getClassLoader();
    InputStream is = classLoader.getResourceAsStream("pro.properties");
    pro.load(is);

    //2.获取配置文件中定义的数据
    String className = pro.getProperty("className");
    String methodName = pro.getProperty("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);
}
代码几个：
demo02.Act
cat
cat无参构造！

三、注解

* 属性：接口中的抽象方法
	* 要求：
		1. 属性的返回值类型有下列取值
			* 基本数据类型
			* String
			* 枚举
			* 注解
			* 以上类型的数组	
* 元注解：用于描述注解的注解
		* @Target：描述注解能够作用的位置
			* ElementType取值：
			* TYPE：可以作用于类上
			* METHOD：可以作用于方法上
			* FIELD：可以作用于成员变量上
		* @Retention：描述注解被保留的阶段
		* @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
		* @Documented：描述注解是否被抽取到api文档中
		* @Inherited：描述注解是否被子类继承

练习：

public class Act {
    private String name;
public void cat(){
    System.out.println("cat无参构造！");
}
}

@Target(ElementType.TYPE)//注解只能加在类上
@Retention(RetentionPolicy.RUNTIME)//在运行时
public @interface MyZhuJie {
    String className();
    String methodName();
}

@MyZhuJie(className = "demo02.Act",methodName = "cat")
public class Reflect2 {
    public static void main(String[] args) throws Exception{

        //获取注解的对象
        MyZhuJie zhuJie = Reflect2.class.getAnnotation(MyZhuJie.class);

        //调用方法
        String className = zhuJie.className();
        String methodName = zhuJie.methodName();
        System.out.println("className = " + className);
        System.out.println("methodName = " + methodName);

        //3.加载该类进内存
        Class cls = Class.forName(className);
        //4.创建对象
        Object obj = cls.newInstance();
        //5.获取方法对象
        Method method = cls.getMethod(methodName);
        //method.setAccessible(true);
        //6.执行方法
        method.invoke(obj);
    }
}
代码效果：
className = demo02.Act
methodName = cat
cat无参构造！