JAVA中Junit,反射和注解

最新推荐文章于 2022-09-24 19:28:39 发布

MilkBerg

最新推荐文章于 2022-09-24 19:28:39 发布

阅读量123

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/weixin_43153854/article/details/103121864

版权

java 专栏收录该内容

42 篇文章 0 订阅

订阅专栏

一.Junit单元测试

1.Junit概述

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

2.Junit的使用步骤

junit:白盒测试
步骤：
（1）定义一个测试类（测试用例）
建议
测试类名：被测试的类名Test CalculatorTest
包名：xxx.xxx.xx.test cn.itcast.test
（2）定义测试方法：可以独立运行
建议
方法名：test测试的方法名 testAdd()
返回值：void
参数列表：空参
（3）给方法加@Test
（4）导入junit依赖环境
（5）判定结果
红色：成功
绿色：失败
一般使用断言操作处理结果
Assertions.assertEquals();
@BeforeAll:修饰的方法会在测试方法之前执行
@AfterAll:修饰的方法会在测试之后执行

package cn.itcast.test;

import cn.itcast.junit.Calculator;
import org.junit.jupiter.api.*;

public class CalculatorTest {

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

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

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

        //3.断言 断言这个结果是3
        Assertions.assertEquals(3,result);
    }

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

二.反射

1.反射的概述

反射是框架设计的灵魂（框架：半成品软件，可以在框架的基础上进行软件开发，简化编码）

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

好处：

可以在程序运行过程中，操作这些对象。
可以解耦，提高程序的可扩展性。

获取Class对象的方式：

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

package reflect;

import domain.Person;
import domain.Student;

/*
    获取class的三种方式：
         1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
         2. 类名.class:通过类名的属性class获取
         3. 对象.getClass（）:getClass()方法在Object类中定义
 */
public class ReflectDemo01GetClass {
    public static void main(String[] args) throws ClassNotFoundException {

        //1. Class.forName("全类名")
        Class cls1 = Class.forName("domain.Person");
        System.out.println(cls1);
        //2. 类名.class
        Class<Person> 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);
        //每一个字节码文件对应的Class类对象都不相同


    }
}

结论：
同一个字节码文件（.class）在一次程序运行过程中，只会被加载一次，不论通过哪一种方式对象都是同一个。
每一个字节码文件对应的Class类对象都不相同。
在这里插入图片描述
第一个阶段（源代码阶段）：

先从java文件按成员变量，构造方法，成员方法通过javac编译成class文件。如上图Person.java–>Person.class

第二个阶段（Class类对象阶段）：

通过类加载器把class文件中的成员变量，构造方法，成员方法加载到内存中。

第三个阶段（Runtime运行时阶段）：

该阶段就可以创建对象和调用对象里的方法了。

Class对象功能：
1.获取功能：
（1）获取成员变量们

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

Filed：成员变量
操作
1.设置值set(Object obj, Object value)
2.获取值get(Object obj)
3.在访问之前忽略访问权限修饰符的安全检查setAccessible(true)：暴力反射

package reflect;

import domain.Person;

import java.lang.reflect.Field;

/*
    （1）获取成员变量们

 -  `Field[] getFields()`
 - `Field getField(String name)`
 - `Field[] getDeclaredFields()`
 - `Field getDeclaredField(String name)`

（2）获取构造方法们

 - `Constructor<T> getConstructor(Class<?>... parameterTypes)`
 - `Constructor<?>[] getConstructors()`
 -  `Constructor<?>[] getDeclaredConstructors()`
 - `Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)`

（3）获取成员方法们

 - `Method[] getMethods()`
 - `Method getMethod(String name, Class<?>... parameterTypes)`
 - `Method[] getDeclaredMethods()`
 -  `Method getDeclaredMethod(String name, Class<?>... parameterTypes)`


（4）获取类名

 - String getName()
 */
public class ReflectDemo02GetFields {
    public static void main(String[] args) throws Exception {
        //1.获取Person的Class对象
        Class<Person> personClass = Person.class;
        /*
            （1）获取成员变量们
             - Field[] getFields()获取所有public修饰的成员变量
             - Field getField(String name)获取指定名称public修饰的成员变量

             - Field[] getDeclaredFields()获取所有的成员变量
             - Field getDeclaredField(String name)
         */
        //- Field[] getFields()
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("--------------------------");
        //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);
        }
        System.out.println("------------------------------");
        //Field getDeclaredField(String name)
        Field d = personClass.getDeclaredField("d");
        //在访问之前忽略访问权限修饰符的安全检查
        d.setAccessible(true);//暴力反射
        Object value2 = d.get(p);
        System.out.println(value2);


    }
}

（2）获取构造方法们

Constructor<T> getConstructor(Class<?>... parameterTypes)
Constructor<?>[] getConstructors()
Constructor<?>[] getDeclaredConstructors()
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)

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

package reflect;

import domain.Person;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/*


（2）获取构造方法们

 -Constructor<T> getConstructor(Class<?>... parameterTypes)
 -Constructor<?>[] getConstructors()
 -Constructor<?>[] getDeclaredConstructors()
 -Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)


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

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

        Person person1 = constructor1.newInstance();
        System.out.println(person1);
        System.out.println("------------------");
        Person person2 = personClass.newInstance();
        System.out.println(person2);

    }
}

（3）获取成员方法们

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

Method:方法对象
执行方法：
Object invoke(Object obj, Object… args)

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

package reflect;

import domain.Person;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

/*
（3）获取成员方法们

 - Method[] getMethods()
 - Method getMethod(String name, Class<?>... parameterTypes)
 - Method[] getDeclaredMethods()
 - Method getDeclaredMethod(String name, Class<?>... parameterTypes)

 */
public class ReflectDemo03GetMethods {
    public static void main(String[] args) throws Exception {
        //1.获取Person的Class对象
        Class<Person> 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("-----------------------");
        //获取所有方法public修饰的方法
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
            String name = method.getName();
            System.out.println(name);
        }

    }
}

（4）获取类名

String getName()

//获取类名
//                - String getName()
        String className = personClass.getName();
        System.out.println(className);

2.反射的案例

package reflect;

import domain.Person;

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

/*
    需求：写一个框架，不能改变该类的任何代码，可以创建任意类的对象，可以执行任意的方法
        实现：
            1.配置文件
            2.反射
        步骤：
            1.将需要创建的对象的全类名和需要执行的方法定义在配置文件中
            2.在程序中加载读取配置文件
            3.使用反射技术加载类文件进内存
            4.创建对象
            5.执行方法
 */
public class ReflectDemo05Case {
    public static void main(String[] args) throws Exception {
        //可以创建任意类的对象，可以去执行任意方法

        /*
            前提：不能改变该类的任何代码，可以创建任意类的对象，可以执行任意的方法
         */
        /*
        Person p = new Person();
        p.eat();
        */

        //1.加载配置文件
        //1.1创建Properties对象
        Properties pro = new Properties();
        //1.2.加载配置文件，转换为一个双列集合
        //1.2.1获取class目录下的配置文件
        ClassLoader classLoader = ReflectDemo05Case.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);


    }
}

pro.properties文件

className=domain.Student
methodName=sleep

MilkBerg

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA中Junit,反射和注解

一.Junit单元测试1.Junit概述测试分类：（1）黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。（2）白盒测试：需要写代码。关注程序具体的执行流程。2.Junit的使用步骤junit:白盒测试步骤：（1）定义一个测试类（测试用例）建议测试类名：被测试的类名Test CalculatorTest包名：xxx.xxx.xx.test cn.itcast....
复制链接

扫一扫