Java基础-单元测试和反射的相关内容

于 2023-04-04 17:42:29 发布
阅读量576 收藏
点赞数
分类专栏： javaSE 文章标签： java junit 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wwl193206126/article/details/129951880
版权

系列文章目录

JavaSE基础的单元测试和反射相关内容的学习

文章目录

前言

一、单元测试

1.单元测试概述

在这里插入图片描述
在这里插入图片描述

2.单元测试快速入门

在这里插入图片描述

package org.example.junit;

public class UserService {
    public String loginName(String loginName,String password){
        if ("admin".equals(loginName)&&"123".equals(password)){
            return "登录成功";
        }else {
            return "登录失败";
        }
    }
    public void selectName(){
        System.out.println(10/0);
        System.out.println("查询用户成功");
    }
}


package org.example.junit;

import org.junit.Assert;
import org.junit.Test;

/**
 * 测试类
 */
public class TestUserService {
    /**
     * 测试方法必须无参且无返回值
     */
    @Test
    public void testLoginName(){
        UserService userService=new UserService();
        String rs = userService.loginName("admin", "123");

        //进行预期结果的正确性测试：  断言
        Assert.assertEquals("您的功能出现问题","登录成功",rs);
    }

    @Test
    public void testUserSelect(){
        UserService userService=new UserService();
        userService.selectName();
    }
}

3.单元测试常用注解

在这里插入图片描述

在这里插入图片描述

package org.example.junit;

import org.junit.*;

/**
 * 测试类
 */
public class TestUserService {

    //修饰实例方法
    @Before
    public void before(){
        System.out.println("=============before方法执行========");
    }
    @After
    public void after(){
        System.out.println("===============after方法执行============");
    }

    //修饰静态方法
    @BeforeClass
    public static void beforeClass(){
        System.out.println("============beforeClass方法执行==============");
    }

    @AfterClass
    public static void afterClass(){
        System.out.println("===============afterClass方法执行=============");
    }

    /**
     * 测试方法必须无参且无返回值
     */
    @Test
    public void testLoginName(){
        UserService userService=new UserService();
        String rs = userService.loginName("admin", "123");

        //进行预期结果的正确性测试：  断言
        Assert.assertEquals("您的功能出现问题","登录成功",rs);
    }

    @Test
    public void testUserSelect(){
        UserService userService=new UserService();
        userService.selectName();
    }
}

二、反射

1.反射概述

在这里插入图片描述

2.反射获取类对象

在这里插入图片描述

package org.example.reflect_class;

/**
 * 目标：反射第一步：获取class类对象
 */
public class Test {
    public static void main(String[] args) throws Exception {
        //1.class类中的一个静态方法：forName
        Class c=Class.forName("org.example.reflect_class.Student");
        System.out.println(c);

        //2.类名.class
        Class c1=Student.class;
        System.out.println(c1);

        //3.对象.getClass() 获取对象对应的类的class类对象
        Student s=new Student();
        Class c2=s.getClass();
        System.out.println(c2);
    }
}

3.反射获取构造器对象

使用反射获取构造器对象并创建对象

在这里插入图片描述

package org.example.reflect_constructer;

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

    public Student() {
        System.out.println("无参构造器执行");
    }

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

    public Student(String name, int age) {
        System.out.println("有参构造器执行");
        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;
    }
}


package org.example.reflect_constructer;

import org.junit.Test;

import java.lang.reflect.Constructor;

public class TestStudent {

    /**
     * 提取共有属性的构造器
     */
    @Test
    public void getConstructors(){
        //a.第一步：获取类对象
        Class c=Student.class;
        //b.第二部：提取类中全部构造器对象
        Constructor[] constructors = c.getConstructors();
        //c.遍历构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName()+"====>"+constructor.getParameterCount());
        }
    }

    /**
     * 提取所有构造器
     */
    @Test
    public void getDeclaredConstructors(){
        //a.第一步：获取类对象
        Class c=Student.class;
        //b.第二部：提取类中全部构造器对象
        Constructor[] constructors = c.getDeclaredConstructors();
        //c.遍历构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName()+"====>"+constructor.getParameterCount());
        }
    }


    @Test
    public void getConstructor() throws Exception {
        //a.第一步：获取类对象
        Class c=Student.class;
        //b.第二部：定位单个构造器对象  (按照参数定位无参构造器)
        Constructor cons = c.getConstructor();
        System.out.println(cons.getName()+"====>"+cons.getParameterCount());
    }


    @Test
    public void getDeclaredConstructor() throws Exception {
        //a.第一步：获取类对象
        Class c=Student.class;
        //b.第二部：定位某个有参构造器对象
        Constructor cons = c.getDeclaredConstructor(String.class,int.class);
        System.out.println(cons.getName()+"====>"+cons.getParameterCount());
    }
}

在这里插入图片描述

在这里插入图片描述

package org.example.reflect_constructer;

import org.junit.Test;

import java.lang.reflect.Constructor;

public class TestStudent2 {

    //调用构造器得到一个对象并返回
    @Test
    public void getDeclaredConstructor() throws Exception {
        //a.第一步：获取类对象
        Class c=Student.class;
        //b.第二部：定位某个有参构造器对象
        Constructor cons = c.getDeclaredConstructor();
        System.out.println(cons.getName()+"====>"+cons.getParameterCount());

        //如果遇到私有构造器，可以暴力反射
        cons.setAccessible(true);//权限被打开
        Student s= (Student) cons.newInstance();
        System.out.println(s);

        Constructor cons1 = c.getDeclaredConstructor(String.class,int.class);
        System.out.println(cons1.getName()+"====>"+cons1.getParameterCount());
        Student s1 = (Student) cons1.newInstance("孙悟空", 50000);
        System.out.println(s1);
    }


    
}

4.反射获取成员变量对象

使用反射获取成员变量并使用

在这里插入图片描述

package org.example.reflect_filed;

import org.junit.Test;

import java.lang.reflect.Field;

public class FiledDemo01 {
    //1.获取全部成员变量
    @Test
    public void getDeclaredFields(){
        //a.定位class对象
        Class c=Student.class;
        //b.定位全部成员变量
        Field[] fields = c.getDeclaredFields();
        //c.遍历成员变量
        for (Field field : fields) {
            System.out.println(field.getName()+"==>"+field.getType());
        }
    }


    //2.获取某个成员变量
    @Test
    public void getDeclaredField() throws Exception {
        //a.定位class对象
        Class c=Student.class;
        //b.根据名称定位某个成员变量
        Field field = c.getDeclaredField("age");
        System.out.println(field.getName()+"==>"+field.getType());
    }
}

在这里插入图片描述

package org.example.reflect_filed;

import org.junit.Test;

import java.lang.reflect.Field;

public class FieldDemo02 {

    @Test
    public void setField() throws Exception {
        //a.定位class对象
        Class c=Student.class;
        //b.根据名称定位某个成员变量
        Field field = c.getDeclaredField("age");

        field.setAccessible(true);
        //c.赋值
        Student s=new Student();
        field.set(s,18);

        System.out.println(s);

        //d.取值
        int age = (int) field.get(s);
        System.out.println(age);

    }
}

5.反射获取方法对象

在这里插入图片描述

在这里插入图片描述

package org.example.reflect_method;

public class Dog {
    private String name;

    public Dog() {
    }

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

    public void run(){
        System.out.println("狗跑得很快~~");
    }

    public void eat(){
        System.out.println("狗吃骨头~~");
    }

    public String eat(String name){
        System.out.println("狗吃"+name);
        return "吃得很开心";
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


package org.example.reflect_method;

import org.junit.Test;

import java.lang.reflect.Method;

public class MethodDemo {
    //1.获取类中所有成员方法对象
    @Test
    public void getDeclaredMethods(){
        //a.获取类对象
        Class c=Dog.class;
        //b.提取全部方法：包括私有
        Method[] methods = c.getDeclaredMethods();
        //c.遍历全部方法
        for (Method method : methods) {
            System.out.println(method.getName()+"====>"+method.getReturnType()+"===>"+method.getParameterCount());
        }
    }

    //2.获取类中某个成员方法对象
    @Test
    public void getDeclaredMethod() throws Exception {
        //a.获取类对象
        Class c=Dog.class;
        //b.提取全部方法：包括私有
        Method m = c.getDeclaredMethod("eat");
        Method m2 = c.getDeclaredMethod("eat",String.class);


        m.setAccessible(true);
        //c.触发方法的执行
        Dog d=new Dog();
        //注意：如果方法是没有结果回来的，那么返回的是null
        Object rs = m.invoke(d);
        System.out.println(rs);

        Object rs2 = m2.invoke(d, "骨头");
        System.out.println(rs2);


    }
}

6.反射的作用—泛型擦除

在这里插入图片描述

package org.example.reflect_genericity;

import java.lang.reflect.Method;
import java.util.ArrayList;

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        //需求：反射实现泛型擦除后，加入其他类型的元素
        ArrayList<String> list1=new ArrayList<>();
        ArrayList<Integer> list2=new ArrayList<>();

        System.out.println(list1.getClass());
        System.out.println(list2.getClass());

        System.out.println(list1.getClass()==list2.getClass());

        System.out.println("==========================");
        list2.add(23);
        list2.add(34);


        Class c=list2.getClass();
        //定位c类中的add方法
        Method add=c.getDeclaredMethod("add",Object.class);
        boolean rs = (boolean) add.invoke(list2, "孙悟空");

        System.out.println(list2);
        System.out.println(rs);
    }
}

7.反射的作用—通用框架的底层原理

在这里插入图片描述

在这里插入图片描述

package org.example.reflect_framerwork;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class MybatisUtils {
    public static void save(Object o)  {

        try (
                PrintStream ps=new PrintStream(new FileOutputStream("junit-reflect-app/src/data.txt",true));
                ){

            //1.提取这个对象的全部成员变量，只有反射可以解决
            Class c=o.getClass();//c.getSimpleName()获取当前类名 c.getName()获取包名+类名
            ps.println("=============="+c.getSimpleName()+"===================");
            Field[] fields = c.getDeclaredFields();
            //2.获取成员变量信息
            for (Field field : fields) {
                field.setAccessible(true);
                String name=field.getName();
                //3.提取本成员变量在obj中的值（取值）
                String value = field.get(o) + "";
                ps.println(name+"="+value);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


package org.example.reflect_framerwork;


/**
 *      目标：提供一个通用对象，支持保持所有对象的具体信息
 *
 */
public class ReflectDemo {
    public static void main(String[] args) {
        Student s=new Student();
        s.setName("孙悟空");
        s.setSex('男');
        s.setAge(10000);
        s.setNumber(1956842);
        MybatisUtils.save(s);
        Teacher t=new Teacher();
        t.setName("如来");
        t.setSalary(12265.0);
        MybatisUtils.save(t);
    }
}


package org.example.reflect_framerwork;

public class Student {
    private String name;
    private int age;
    private long number;
    private char sex;

    public Student() {
    }

    public Student(String name, int age, long number, char sex) {
        this.name = name;
        this.age = age;
        this.number = number;
        this.sex = sex;
    }

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

    public long getNumber() {
        return number;
    }

    public void setNumber(long number) {
        this.number = number;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

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


package org.example.reflect_framerwork;

public class Teacher {
    private String name;
    private double salary;

    public Teacher() {
    }

    public Teacher(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

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

总结

本节主要介绍的是单元测试的基本用法和反射常见的API，并介绍了反射的作用，做高级框架和泛型擦除。

尘开的笔记
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java反射测试
m0_62762361的博客
02-21 92
/ Student studentA = (Student) constructor2.newInstance("张三");System.out.println("你输入的名字是:" + name);System.out.println("你输入的年龄是:" + age);System.out.println("我的年龄：" + age);System.out.println("我的年龄：" + age);// method1.invoke(studentD,"王五");
【Java学习笔记】单元测试、反射、注解、动态代理
weixin_52144018的博客
03-22 334
【Java学习笔记】单元测试、反射、注释、动态代理
Junit单元测试、反射
小孩与狗的博客
08-13 145
Junit单元测试： 测试分类： 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。功能测试。 白盒测试：需要写代码的。关注程序具体的执行流程。 灰盒测试：既有一些功能使用黑盒测试又有一些功能白盒测试。 Junit使用：白盒测试 定义一个测试类(测试用例) 测试类名：被测试的类名Test CalculatorTest 包名：xxx.xxx.xx.test com.xxx.test 定义测试方法：可以独立运行 方法名：test测试的方法名 testAdd() 返回值：void 参
Java反射机制的简单测试
会者定离，一期一祈
12-26 626
什么是反射？ Java 反射，就是在运行状态中。 获取任意类的名称、包信息、所有属性、方法、注解、类型、类加载器等 获取任意对象的属性，并且改变它 实例化任意一个类的对象 调用任意对象的方法 在反射面前, 毫无秘密可言 通过反射可以实现动态装配，降低耦合度，但是反射的过度使用会严重消耗系统资源。 反射相关的主要API java.lang.Class : 代表一个类 java.lang.reflect.Method : 代表类中方法 java.lang.reflect.Field : 代表类
单元测试 反射 注解
weixin_51621893的博客
02-23 275
今日内容 单元测试 测试概述 在我们编写代码的时候，开发了很多功能，我们需要对这些已经开发好的功能提前进行测试，检测功能方法是否有漏洞，是否有bug，这个时候我们可以使用Junit单元测试对我们开发的代码进行测试。 Junit是Java语言的单元测试框架，属于第三方的一个工具，一般情况下我们需要导入相应的jar包，对于目前使用的集成开发工具自带的，我们今天是以Idear开发工具为主 Junit属于白盒测试 测试分类 黑盒测试：大多数测试的细节隐藏起来，通常使用的一些软件进行测试
实例讲解Java基础之反射
08-26
反射在很多场景下都有应用，如框架开发（如Spring框架的依赖注入）、序列化/反序列化、单元测试、动态代理等。然而，由于反射涉及到安全性、性能和易维护性的问题，因此在不必要的情况下应避免过度使用。在实际开发...
java基础巩固，思考 java-se java基础巩固，思考，从底层到精通 测试一个
最新发布
06-24
2. **Mockito**：了解Mockito框架，用于模拟对象和依赖项，以便在单元测试中隔离被测试代码。 3. **集成测试**：在应用程序组件之间进行测试，确保不同部分协同工作。 4. **持续集成/持续部署（CI/CD）**：熟悉...
test-java-project-3:Java测试
05-11
总的来说，"test-java-project-3:Java测试"是一个涵盖Java编程和测试实践的综合项目，旨在帮助开发者巩固基础，理解测试流程，并掌握如何有效地测试Java代码。通过参与这样的项目，可以提升编程技能，更好地理解如何...
Java基础之注解+反射.docx
05-17
- 反射在框架开发、插件系统、单元测试、序列化、动态代理等领域有广泛应用，如Hibernate ORM框架使用反射操作数据库，JUnit测试框架通过反射调用测试方法。 总的来说，Java注解提供了静态元数据，使得程序员可以...
Java反射机制测试Demo
02-27
首先，`Class`对象是反射的基础，每个类在内存中都有一个对应的`Class`对象，通过这个对象我们可以获取到类的所有信息，包括类名、访问修饰符、父类、接口、构造器、方法和字段等。`Class`对象可以通过以下三种方式...
单元测试、反射、注解、动态代理
weixin_43584531的博客
03-16 632
JUnit单元测试的实现过程是什么样的？ 必须导入Junit框架的jar包。 定义的测试方法必须是无参数无返回值，且公开的方法。 测试方法使用@Test注解标记。 JUnit测试某个方法，测试全部方法怎么处理？ 成功的标志是什么 测试某个方法直接右键该方法启动测试。 测试全部方法，可以选择类或者模块启动。 红色失败，绿色通过。 注解 说明 @Test 测试方法 @Before 用来.
Junit单元测试、反射、注解
http://www.onlyze.cn/
09-20 756
一、Junit单元测试     1、单元测试：可以代替掉程序中的main方法。程序可以从单元测试方法开始执行。     使用：         1. 要在单元测试方法上面加上注解 @Test         2. 以单元测试的方式去运行即可。     要求：         1. 单元测试方法的方法名一般以test开头 （软性规定）         2. 单元测试方法要以public...
基础强化 单元测试、反射、注解
xiongmaogaizi的博客
12-21 125
Web
单元测试&反射机制（未完结）
weixin_43529244的博客
11-11 361
单元测试 单元测试是指程序猿写的测试代码给自己的类中的方法进行预期正确性的验证 单元测试一旦写好了这些测试代码，就可以一直使用，可以实现一定程度上的自动化验证 单元测试一般是要使用框架进行 单元测试的经典框架：Junit Junit是什么？ Junit是Java语言编写的第三方单元测试框架 Junit框架的方案可以帮助我们方便且快速的测试我们代码的正确性 单元测试概念 单元：在Java，一个类就是一个单元 单元测试：程序员用Junit编写的一小段代码，用来对某个方法进行功能测试或业务逻辑测试。 Ju
单元测试+反射+注解知识点总结
weixin_44536951的博客
02-23 261
单元测试 测试概述 在我们编写代码的时候，开发了很多功能，我们需要对这些已经开发好的功能提前进行测试，检测功能方法是否有漏洞，是否有bug，这个时候我们可以使用Junit单元测试对我们开发的代码进行测试。 Junit是Java语言的单元测试框架，属于第三方的一个工具，一般情况下我们需要导入相应的jar包，对于目前使用的集成开发工具自带的，我们今天是以Idear开发工具为主 Junit属于白盒测试 测试分类 黑盒测试:大多数测试的细节隐藏起来,通常使用的一些软件进行测试 白盒测试:大多数是需要写一些代码
java反射在单元测试中的应用
A6__6A
07-06 958
反射
java之Junit单元测试、反射和注解总结
xiaoyong5854的博客
07-05 704
1 Junit单元测试 测试分类： 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。 白盒测试：需要写代码的。关注程序具体的执行流程。 Junit使用：白盒测试 定义一个测试类(测试用例) 测试类名：被测试的类名Test Demo02Calculator 包名：xxx.xxx.xx.test package Demo01 定义测试方法：可以独立运行 * 方法名：test测试的方法名 testAdd() * 返回值：void *
【Java】浅析Junit单元测试+反射+注解
丧心病狂Loli控的博客
07-20 223
测试分为黑盒测试和白盒测试 Junit单元测试属于白盒测试 测试一个类，就创建一个"与这个类所在包并列的test包，test包中创建Test类" 命名规范： 包名：test 类名：被测试类名+Test 方法名：test+被测试方法名 推荐的测试写法： 返回值void，参数为空，函数体内直接断言 结果判定： 绿色成功，红色失败(因为使用了断言，因此一般不看运行结果) --------------------------------------- Demo：测试Calculator的add()方
day01_基础加强_docx1
08-04
Day01_基础加强0.1 学习目标1、能够掌握 junit 单元测试2、能够掌握反射原理3、能够掌握注解的应用0.2 学习指南Junit 单元测试（重要）反射（重要）注解（重点） 在Day01_基础加强0.1中，我们学习了如何掌握 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值