java学习记录二十三：单元测试，反射

最新推荐文章于 2022-05-21 19:43:17 发布
最新推荐文章于 2022-05-21 19:43:17 发布
阅读量198 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48459838/article/details/118523755
版权

java学习记录二十三：单元测试，反射

一、单元测试

一、解释

让方法独立运行，可以不在整个程序里运行，进行简单调试。使用第三方的包。

二、Junit的概念

概述 : Junit是Java语言编写的第三方单元测试框架(工具类)

  • 作用 : 用来做“单元测试”——针对某个普通方法，可以像main()方法一样独立运行，它专门用于测试某个方法。

三、Junit的使用步骤

  • 1.在模块下创建lib文件夹,把Junit的jar包复制到lib文件夹中
  • 2.选中Junit的jar包,右键选中 add as Library,把JUnit4的jar包添加到classPath中，每个第三方包都要这么导入。
  • 3.在测试方法上面写上@Test注解
  • 4.执行测试方法
public class Person {

    @Test
    public void test1(){
        System.out.println("Person test1 方法执行了....");
    }

    @Test
    public void test2(){
        System.out.println("Person test2 方法执行了....");
    }

}

执行测试方法

  • 1.选中方法名—>右键—>选中执行 只执行选中的测试方法
  • 2.选中类名----->右键—>选中执行 执行该类中所有的测试方法
  • 3.选中模块---- ->右键—>选中all tests 执行 执行该模块中所有的测试方法
  • 如何查看测试结果
    • 绿色：表示测试通过
    • 红色：表示测试失败，有问题

四、Junit单元测试的注意实现

  • 1.测试方法的权限修饰符一定是public
  • 2.测试方法的返回值类型一定是void
  • 3.测试方法一定没有参数
  • 4.测试方法 的声明之上一定要使用@Test注解

五、Junit其他注解

  • @Before：用来修饰方法，该方法会在每一个测试方法执行之前执行一次。
  • @After：用来修饰方法，该方法会在每一个测试方法执行之后执行一次。
  • @BeforeClass：用来静态修饰方法，该方法会在所有测试方法之前执行一次，而且只执行一次。
  • @AfterClass：用来静态修饰方法，该方法会在所有测试方法之后执行一次，而且只执行一次。
public class Student {

    @BeforeClass
    public static void beforeClass1(){
        System.out.println("Student beforeClass1静态方法执行了...");
    }

    @BeforeClass
    public static void beforeClass2(){
        System.out.println("Student beforeClass2静态方法执行了...");
    }


    @Before
    public void b1(){
        System.out.println("Student b1方法执行了...");
    }

    @Before
    public void b2(){
        System.out.println("Student b2方法执行了...");
    }

    @Before
    public void b3(){
        System.out.println("Student b3方法执行了...");
    }


    @Test
    public void test1(){
        System.out.println("Student test1 方法执行了....");
    }

    @Test
    public void test2(){
        System.out.println("Student test2 方法执行了....");
    }

    @After
    public void a1(){
        System.out.println("Student a1方法执行了...");
    }

    @After
    public void a2(){
        System.out.println("Student a2方法执行了...");
    }

    @After
    public void a3(){
        System.out.println("Student a3方法执行了...");
    }

    @AfterClass
    public static void afterClass1(){
        System.out.println("Student afterClass1方法执行了...");
    }

    @AfterClass
    public static void afterClass2(){
        System.out.println("Student afterClass2方法执行了...");
    }

}

六、Junit断言

预先判断某个条件一定成立，如果条件不成立，则直接报错。 使用Assert类中的assertEquals()方法

public class Demo02 {
    @Test
    public void addTest(){
        //测试
        int add = add(3, 6);

        //断言判断结果
        //第一个参数表示期望值
        //第二个参数表示实际值
        //如果结果正确的就测试通过,如果结果错误的,就会报错
        Assert.assertEquals(9,add);
    }

    //加法
    //这个代码的语法没问题，也没有异常。他是逻辑错误，系统不知道你要算的是加法
    public int add(int a, int b){
        int sum = a * b;
        return sum;
    }

}

二、反射

一、解释

反射是一种机制，利用该机制可以在程序运行过程中对类进行解剖并操作类中的所有成员(成员变量，成员方法，构造方法)

二、类加载器

类的加载
当我们的程序在运行后，第一次使用某个类的时候，会将此类的class文件读取到内存，并将此类的所有信息存储到一个Class对象中
类的加载时机

  1. 创建类的实例。

  2. 类的静态变量，或者为静态变量赋值。

  3. 类的静态方法。

  4. 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。

  5. 初始化某个类的子类。

  6. 直接使用java.exe命令来运行某个主类。

    以上六种情况的任何一种，都可以导致JVM将一个类加载到方法区。

 // 类的加载时机
        //  1. 创建类的实例。
        //  Student stu = new Student();

        // 2. 类的静态变量，或者为静态变量赋值。
        // Person.country = "中国";

        // 3. 类的静态方法。
        // Person.method();

        // 4. 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。
        // Class<?> c = Class.forName("com.itheima.demo1_类的加载.Student");

        //  5. 初始化某个类的子类。
        // Zi zi = new Zi();

        // 6. 直接使用java.exe命令来运行某个主类。

类加载器
类加载器：是负责将磁盘上的某个class文件读取到内存并生成Class的对象，当读取类文件时，就加载到内存中。

  • Java中有三种类加载器，它们分别用于加载不同种类的class：
    • 启动类加载器(Bootstrap ClassLoader)：用于加载系统类库<JAVA_HOME>\bin目录下的class，例如：rt.jar。
    • 扩展类加载器(Extension ClassLoader)：用于加载扩展类库<JAVA_HOME>\lib\ext目录下的class。
    • 应用程序类加载器(Application ClassLoader)：用于加载我们自定义类的加载器。
/*
            类加载器:
                概述:是负责将磁盘上的某个class文件读取到内存并生成Class的对象。
                如何获取类加载器:
                    类的字节码对象.getClassLoader()
         */
        // 获取Test类的类加载器
        ClassLoader c1 = Test.class.getClassLoader();
        System.out.println(c1);// AppClassLoader

        // 获取Student类的类加载器
        ClassLoader c2 = Student.class.getClassLoader();
        System.out.println(c2);// AppClassLoader

        // 获取String类的类加载器
        ClassLoader c3 = String.class.getClassLoader();
        System.out.println(c3);// null
        //API中说明：一些实现可能使用null来表示引导类加载器。 如果此类由引导类加载器加载，则此方法将在此类实现中返回null

        System.out.println("====================委派机制=================");
        System.out.println(c1.getParent());// PlatformClassLoader
        System.out.println(c1.getParent().getParent());// null

三、反射的使用

IDEA中的对象通过反射技术对象类进行了解剖得到了类的所有成员。知道类有哪些属性，哪些方法。
使用反射操作类成员的前提
要获得该类字节码文件对象，就是Class对象
反射在实际开发中的应用

  • 开发IDE(集成开发环境)，比如IDEA,Eclipse
  • 各种框架的设计和学习 比如Spring，Hibernate，Struct，Mybaits…
  • 通过反射技术去获取一个类的成员变量,成员方法,构造方法…,并可以访问

四、Class对象的获取方式

  • 通过类名.class获得
  • 通过对象名.getClass()方法获得
  • 通过Class类的静态方法获得： static Class forName(“类全名”)
  • 每一个类的Class对象都只有一个。
public class Student {
    private String name;

    public void method1(){

    }
}

// 1.方式一:通过类名.class获得
        Class<Student> c1 = Student.class;
        System.out.println(c1);

        // 2.方式二:通过对象名.getClass()方法获得
        Student stu = new Student();
        Class<? extends Student> c2 = stu.getClass();
        System.out.println(c2);

        // 3.方式三:通过Class类的静态方法获得： static Class forName("类全名")
        Class<?> c3 = Class.forName("com.itheima.demo2_Class对象的获取.Student");
        System.out.println(c3);

        // 问题:一个类只有一个字节码对象(Class对象)
        System.out.println(c1 == c2);// true
        System.out.println(c1 == c3);// true

五、Class类常用方法

String getSimpleName(); 获得类名字符串：类名
String getName(); 获得类全名：包名+类名
T newInstance() ; 创建Class对象关联类的对象

 // 获得Class对象
        Class c = Student.class;
        // 获得类名字符串：类名
        System.out.println(c.getSimpleName());
        // 获得类全名：包名+类名
        System.out.println(c.getName());
        // 创建对象
        Student stu = (Student) c.newInstance();
        System.out.println(stu);

三、反射之操作构造方法

一、解释

通过反射获取类的构造方法,并执行构造方法

二、Constructor类概述

反射之操作构造方法的目的
获得Constructor对象来创建类的对象。
Constructor类概述
类中的每一个构造方法都是一个Constructor类的对象

三、通过反射获取类的构造方法

Class类中与Constructor相关的方法 
1. Constructor getConstructor(Class... parameterTypes)
        * 根据参数类型获得对应的Constructor对象。
        * 只能获得public修饰的构造方法
 2. Constructor getDeclaredConstructor(Class... parameterTypes)
        * 根据参数类型获得对应的Constructor对象
    	* 可以是public、protected、(默认)、private修饰符的构造方法。
 3. Constructor[] getConstructors()
        获得类中的所有构造方法对象，只能获得public的
 4. Constructor[] getDeclaredConstructors()
        获得类中的所有构造方法对象
    	可以是public、protected、(默认)、private修饰符的构造方法。

四、通过反射执行构造方法

Constructor对象常用方法
1. T newInstance(Object... initargs)
 	根据指定的参数创建对象
2. void setAccessible(true)
   设置"暴力反射"——是否取消权限检查，true取消权限检查，false表示不取消

五、案例

public class Student {
    public String name;
    public int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student(String name) {
        this.name = name;
    }

    private Student(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

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

        // 获取Student类的Class对象
        Class<Student> c = Student.class;

        // 获取单个构造方法
        // 获取无参数的构造方法
        Constructor<Student> con1 = c.getDeclaredConstructor();
        System.out.println(con1);

        // 获取满参构造方法
        Constructor<Student> con2 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(con2);

        // 获取私有构造方法
        Constructor<Student> con3 = c.getDeclaredConstructor(int.class);
        System.out.println(con3);

        System.out.println("================================");
        // 获取所有构造方法
        Constructor<?>[] arr1 = c.getDeclaredConstructors();
        for (Constructor<?> con : arr1) {
            System.out.println(con);
        }

        System.out.println("================================");
        // 通过执行con1表示的构造方法来创建Student对象
        Student stu1 = con1.newInstance();
        System.out.println(stu1);// Student{name='null', age=0}

        // 通过执行con2表示的构造方法来创建Student对象
        Student stu2 = con2.newInstance("张三", 18);
        System.out.println(stu2);// Student{name='张三', age=18}

        // 取消con3表示的构造方法的权限检查
        con3.setAccessible(true);

        // 通过执行con3表示的构造方法来创建Student对象
        Student stu3 = con3.newInstance(19);
        System.out.println(stu3);// Student{name='null', age=19}

    }
}

四、反射之操作成员方法

一、解释

通过反射获取类的成员方法,并执行成员方法

二、Method类概述

反射之操作成员方法的目的
操作Method对象来调用成员方法
Method类概述
每一个成员方法都是一个Method类的对象。

三、通过反射获取类的成员方法

Class类中与Method相关的方法
* Method getMethod(String name,Class...args);
    * 根据方法名和参数类型获得对应的构造方法对象，只能获得public的

* Method getDeclaredMethod(String name,Class...args);
    * 根据方法名和参数类型获得对应的构造方法对象，包括public、protected、(默认)、private的

* Method[] getMethods();
    * 获得类中的所有成员方法对象，返回数组，只能获得public修饰的且包含父类的

* Method[] getDeclaredMethods();
    * 获得类中的所有成员方法对象，返回数组,只获得本类的，包括public、protected、(默认)、private的

四、通过反射执行成员方法

Method对象常用方法
*  Object invoke(Object obj, Object... args)
    * 调用指定对象obj的该方法
    * args：调用方法时传递的参数
*  void setAccessible(true)
    设置"暴力访问"——是否取消权限检查，true取消权限检查，false表示不取消

五、案例

public class Student {

    public void show1() {
        System.out.println("show1 方法...");
    }

    public void show2(int num) {
        System.out.println("show2 方法...num: " + num);
    }

    private void show3() {
        System.out.println("show3 方法...");
    }

    private void show4(String str) {
        System.out.println("show1 方法...str: " + str);
    }

    public int show5(int num) {
        System.out.println("show5 方法...num: " + num);
        return 100;
    }

}

public class Test {
    public static void main(String[] args) throws Exception {
        // 获取Student类的Class对象
        Class<Student> c = Student.class;

        // 获取单个方法
        // 通过反射获取show1方法
        Method m1 = c.getDeclaredMethod("show1");
        System.out.println(m1);

        // 通过反射获取show2方法
        Method m2 = c.getDeclaredMethod("show2", int.class);
        System.out.println(m2);

        // 通过反射获取show3方法
        Method m3 = c.getDeclaredMethod("show3");
        System.out.println(m3);

        // 通过反射获取show4方法
        Method m4 = c.getDeclaredMethod("show4", String.class);
        System.out.println(m4);

        // 通过反射获取show5方法
        Method m5 = c.getDeclaredMethod("show5", int.class);
        System.out.println(m5);

        System.out.println("==============================");
        // 获取所有方法
        Method[] arr = c.getDeclaredMethods();
        for (Method m : arr) {
            System.out.println(m);
        }

        System.out.println("==============================");
        // 通过反射创建Student对象
        Student stu = c.newInstance();

        // 通过反射执行m1表示的show1方法
        m1.invoke(stu);

        // 通过反射执行m2表示的show2方法
        m2.invoke(stu,10);

        // 取消m3表示的方法的权限检查
        m3.setAccessible(true);

        // 通过反射执行m3表示的show3方法
        m3.invoke(stu);

        // 取消m4表示的方法的权限检查
        m4.setAccessible(true);

        // 通过反射执行m4表示的show4方法
        m4.invoke(stu,"itheima");

        // 通过反射执行m5表示的show5方法
        Object res = m5.invoke(stu, 20);// int res = stu.show5(20);
        System.out.println(res);// 100

    }
}

六、扩展反射操作成员方法案例

public class Test {
    public static void main(String[] args)throws Exception {
        /*
            Method类:
            public String getName() 获取方法名
         */
        // 需求: 访问Student类中的成员
        // 1.获取该类的字节码对象
        Class<Student> c = Student.class;

        // 2.获取所有构造方法
        Constructor<?>[] cons = c.getDeclaredConstructors();

        // 3.遍历所有的构造方法
        Student stu = null;
        for (Constructor<?> con : cons) {
            stu = (Student) con.newInstance();
        }

        // 4.获取所有的成员方法
        Method[] methods = c.getDeclaredMethods();

        // 5.遍历所有的成员方法
        for (Method m : methods) {
            if (m.getName().equals("show1")){
                m.invoke(stu);
            }

            if (m.getName().equals("show2")){
                m.invoke(stu,10);
            }

            if (m.getName().equals("show5")){
                Object res = m.invoke(stu, 20);
                System.out.println(res);
            }
            // ...
        }
    }
}

五、反射之操作成员变量

一、解释

通过反射获取类的成员变量,并访问成员变量

二、Field类概述

反射之操作成员变量的目的
* 通过Field对象给对应的成员变量赋值和取值

Field类概述
* 每一个成员变量都是一个Field类的对象。

三、通过反射获取类的成员变量

Class类中与Field相关的方法
* Field getField(String name);
    *  根据成员变量名获得对应Field对象，只能获得public修饰
* Field getDeclaredField(String name);
    *  根据成员变量名获得对应Field对象，包括public、protected、(默认)、private的
* Field[] getFields();
    * 获得所有的成员变量对应的Field对象，只能获得public的
* Field[] getDeclaredFields();
    * 获得所有的成员变量对应的Field对象，包括public、protected、(默认)、private的

四、通过反射访问成员变量

Field对象常用方法
void  set(Object obj, Object value) 
void setInt(Object obj, int i) 	
void setLong(Object obj, long l)
void setBoolean(Object obj, boolean z) 
void setDouble(Object obj, double d) 

Object get(Object obj)  
int	getInt(Object obj) 
long getLong(Object obj) 
boolean getBoolean(Object ob)
double getDouble(Object obj) 

void setAccessible(true);暴力反射，设置为可以直接访问私有类型的属性。
Class getType(); 获取属性的类型，返回Class对象。

setXxx方法都是给对象obj的属性设置使用，针对不同的类型选取不同的方法。

getXxx方法是获取对象obj对应的属性值的，针对不同的类型选取不同的方法。

五、案例

public class Student {
    public String name;
    private int age;
}

public class Test {
    public static void main(String[] args) throws Exception{
  
        // 获取Student类的Class对象
        Class<Student> c = Student.class;
        Student stu = c.newInstance();

        // 获取单个的成员变量
        // 通过反射获取name成员变量
        Field f1 = c.getDeclaredField("name");
        System.out.println(f1);

        // 通过反射获取age成员变量
        Field f2 = c.getDeclaredField("age");
        System.out.println(f2);

        System.out.println("===============================");
        // 获取所有成员变量
        Field[] arr = c.getDeclaredFields();
        for (Field field : arr) {
            System.out.println(field);
        }

        System.out.println("===============================");
        // 获取f1表示的name属性的类型
        System.out.println(f1.getType());
        // 获取f2表示的age属性的类型
        System.out.println(f2.getType());

        System.out.println("===============================");
        // 通过反射给f1表示的name属性赋值
        f1.set(stu,"张三" );// 相当于stu.name="张三";

        // 取消f2表示的属性的权限检查
        f2.setAccessible(true);

        // 通过反射给f2表示的age属性赋值
        f2.set(stu,18 );

        System.out.println("===============================");
        // 通过反射获取f1表示的name属性的值
        System.out.println(f1.get(stu));// 张三

        // 通过反射获取f2表示的age属性的值
        System.out.println(f2.get(stu));// 18


    }
}
努力练级中...
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java-单元测试和反射
ZRX_ZYH的博客
11-03 182
关于Java中的单元测试和反射的学习笔记
【Java】单元测试、反射、注解
张林克的博客
10-04 140
pass
Java单元测试、反射、注解、动态代理
qq_43751200的博客
05-21 403
Java单元测试、反射、注解、动态代理单元测试单元测试快速入门单元测试常用注解反射反射概述反射获取类对象反射获取构造器对象反射获取成员变量对象反射获取方法对象反射的作用-绕过编译阶段为集合添加数据反射的作用-通用框架的底层原理注解注解概述自定义注解元注解注解解析注解的应用场景一：junit框架动态代理 单元测试 单元测试: 就是针对最小的功能单元编写测试代码，Java程序最小的功能单元是方法，因此，单元测试就是针对Java方法的测试，进而检查方法的正确性。 问题提出：目前测试方法是怎么进行的，存在什么问题？
单元测试&反射机制（未完结）
weixin_43529244的博客
11-11 370
单元测试 单元测试是指程序猿写的测试代码给自己的类中的方法进行预期正确性的验证 单元测试一旦写好了这些测试代码，就可以一直使用，可以实现一定程度上的自动化验证 单元测试一般是要使用框架进行 单元测试的经典框架：Junit Junit是什么？ Junit是Java语言编写的第三方单元测试框架 Junit框架的方案可以帮助我们方便且快速的测试我们代码的正确性 单元测试概念 单元：在Java，一个类就是一个单元 单元测试：程序员用Junit编写的一小段代码，用来对某个方法进行功能测试或业务逻辑测试。 Ju
反射+注解实现单元测试
weixin_48741294的博客
08-02 430
主要内容 ​ 注解定义到方法上的应用扩展。通过在目标类中给需要测试的方法加上自定义注解，从而起到标识的作用，再定义一个测试类写测试方法判断目标类中方法是否为待测方法，对其进行测试并将测试结果写到日志中。解决了通过main方法一个一个调用待测方法运行效率低和调多个待测方法而一旦其中一个方法出现异常报错而耽误后续待测方法执行的问题。 反射 ​ 我们在定义好一个Java类之后可对该类成分，可以获取到每个具体属性的值，使用构造方法和普通方法。Java中有个概念是万事万物皆对象，事实上所有的类，类中的属性，类中的方法
注解、反射、单元测试、lombok知识点总结笔记
01-30
在Java编程中，注解（Annotation）、反射（Reflection）、单元测试（Unit Testing）以及Lombok是四个关键的知识点，它们各自扮演着不同的角色，对于提高代码的可维护性、动态性和测试覆盖率至关重要。 注解是一种元...
java学习——java中的反射学习笔记.rar_java 反射
09-21
本篇笔记将深入探讨Java反射的概念、重要性以及如何使用。 一、反射基础 1. 类加载：当Java虚拟机（JVM）加载一个类时，它会创建该类的Class对象。这个对象包含了关于类的所有信息，包括方法、字段、构造器等。...
jcunit:JavaCard 的单元测试框架
06-30
JavaCard 的单元测试框架 为什么是 JCUnit？ JUnit 不适用于 Java Card。 Java Card 没有反射。 Java Card 不支持运行时注释。 并且 Java Card 不会记录异常的堆栈跟踪。 这需要一种不同的方法来实现 Java Card 的...
[Java学习笔记doc]之反射机制
最新发布
08-11
7. 泛型与反射： - 泛型在编译后会擦除，反射获取的`Class`对象并不包含泛型信息，但可以通过类型参数获取实际类型。 8. 性能考虑： - 反射虽然强大，但其性能通常低于直接的静态调用。因此，对于性能敏感的代码...
注解与反射-狂神说Java学习笔记
07-22
在Java编程语言中，注解（Annotation）和反射（Reflection）是两个非常重要的高级特性，它们为程序提供了元数据信息和运行时动态操作类的能力。本文将深入探讨这两个概念及其在实际开发中的应用。 首先，让我们了解...
反射和注解模拟JUnit4单元测试例子
06-19
介绍如何利用反射和注解去简单的模拟JUnit4单元测试的使用，之所以选择JUnit4是因为4.0以后最大的改进就是使用了注解。需要注意的是这里并不是完全的模拟，只是简单实现了一下Runner类和JUnit注解相关的工作流程。所以本文的主要目是介绍反射和注解的使用
Junit单元测试、反射
小孩与狗的博客
08-13 146
Junit单元测试： 测试分类： 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。功能测试。 白盒测试：需要写代码的。关注程序具体的执行流程。 灰盒测试：既有一些功能使用黑盒测试又有一些功能白盒测试。 Junit使用：白盒测试 定义一个测试类(测试用例) 测试类名：被测试的类名Test CalculatorTest 包名：xxx.xxx.xx.test com.xxx.test 定义测试方法：可以独立运行 方法名：test测试的方法名 testAdd() 返回值：void 参
java反射在单元测试中的应用
A6__6A
07-06 965
反射
单元测试、反射和注解
s_crawler的博客
08-09 72
day23单元测试、反射机制、注解、动态代理
xiao_baibai1025的博客
03-14 486
第24天 java 单元测试、反射机制、注解、动态代理
单元测试+反射+注解知识点总结
weixin_44536951的博客
02-23 265
单元测试 测试概述 在我们编写代码的时候，开发了很多功能，我们需要对这些已经开发好的功能提前进行测试，检测功能方法是否有漏洞，是否有bug，这个时候我们可以使用Junit单元测试对我们开发的代码进行测试。 Junit是Java语言的单元测试框架，属于第三方的一个工具，一般情况下我们需要导入相应的jar包，对于目前使用的集成开发工具自带的，我们今天是以Idear开发工具为主 Junit属于白盒测试 测试分类 黑盒测试:大多数测试的细节隐藏起来,通常使用的一些软件进行测试 白盒测试:大多数是需要写一些代码
Java进阶之单元测试、反射、注解
weixin_46278125的博客
06-05 140
Junit单元测试 测试分类： 1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。 2. 白盒测试：需要写代码的。关注程序具体的执行流程。 测试就是对所完成功能的校验，查看功能是否有缺陷有漏洞。在工作中，每次做完功能后都要进行测试，测试通过才可以结束该功能的编写。测试是开发中很重要的一部分。 测试前提 进行单元测试时，一定先要引入Junit包才可以使用。并且@Test该注解必须在方法名上; @BeforeClass：针对所有测试，只执行一次，且必须为static void @Before：
junit,反射,注解
weixin_42252237的博客
12-21 158
junit,反射,注解 1.Junit单元测试 1、测试的分类 A.黑盒测试:不需要写代码 B.白盒测试:需要编写代码(Junit单元测试属于白盒) 2、Junit单元测试的步骤 A.定义测试类(包名称: xxx.xxx.test , 类名称： 需要测试名称Test) B.定义测试方法(可以独立运行,名称:test测试的方法名称,返回值和参数列表空) C.给方法加注解 @Test D.添加Jun...
java反射机制的实现机制_Java反射机制实践
weixin_42398730的博客
02-21 100
前言p.s: 本文需要读者对反射机制的API有一定程度的了解，如果之前没有接触过的话，建议先看一下官方文档的Quick Start。在应用反射机制之前，首先我们先来看一下如何获取一个对象对应的反射类Class，在Java中我们有三种方法可以获取一个对象的反射类。通过getClass方法在Java中，每一个Object都有一个getClass()方法，通过getClass方法我们可以获取到这个对象对...
Java单元测试与反射应用：第五次实验报告
"本次实验是关于软件测试的一个实践，主要采用了Junit进行单元测试，并通过反射技术对受保护的函数进行测试。实验包含了多个测试用例，覆盖了用户登录、课程信息查询、选课、密码修改、课表展示、退课、教务员添加...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值