JAVA单排日记-2020/2/5-Junit-反射

最新推荐文章于 2022-01-08 16:28:06 发布
最新推荐文章于 2022-01-08 16:28:06 发布
阅读量113 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangzilong1995/article/details/104183831
版权

一、反射概述

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。

反射就是把Java类中的各种成分映射成一个个的Java对象。
在这里插入图片描述

二、反射的理解

反射之中包含了一个「反」字，所以想要解释反射就必须先从「正」开始解释。

一般情况下，我们使用某个类时必定知道它是什么类，是用来做什么的。于是我们直接对这个类进行实例化，之后使用这个类对象进行操作。

如：

Phone phone = new Phone(); //直接初始化，「正射」
phone.setPrice(4);

上面这样子进行类对象的初始化，我们可以理解为「正」。

而反射则是一开始并不知道我要初始化的类对象是什么，自然也无法使用 new 关键字来创建对象了。

这时候，我们使用 JDK 提供的反射 API 进行反射调用：

Class clz = Class.forName("com.xxp.reflect.Phone");
Method method = clz.getMethod("setPrice", int.class);
Constructor constructor = clz.getConstructor();
Object object = constructor.newInstance();
method.invoke(object, 4);

上面两段代码的执行结果，其实是完全一样的。但是其思路完全不一样，第一段代码在未运行时就已经确定了要运行的类（Phone），而第二段代码则是在运行时通过字符串值才得知要运行的类（com.xxp.reflect.Phone）。

所以说什么是反射？反射就是在运行时才知道要操作的类是什么，并且可以在运行时获取类的完整构造，并调用对应的方法。

三、反射的常用API

3.1获取反射中的Class对象的三种方式：
  1. Class.forName("类全名")
    Source源代码阶段，将字节码文件加载进内存，返回Class对象。当知道某类的全路径名时，可以使用此静态方法获取 Class 类对象。
    多用于配置文件，将类名定义在配置文件中。读取文件，加载类
Class c1 = Class.forName(“java.lang.String”);
  1. 类名.class
    Class类对象阶段，字节码已经加载到内存中，这种方法只适合在编译前就知道操作的 Class。
    多用于参数的传递
Class c2 = String.class;
  1. 对象.getClass()
    Runtime运行阶段，对象已知，通过对象调用 getClass() 方法来获取
    多用于对象的获取字节码的方式。
String str = new String("Hello");
Class c3 = str.getClass();

使用：
创建Person对象

package junit.reflects;

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

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

主程序：

package junit.reflects;

public class Demo {
    public static void main(String[] args) throws Exception {
        /*
        1.Class.forName("类全名")
        2.类名.class
        3.对象.getClass()
        */

        //1.Class.forName("类全名")
        Class c1 = Class.forName("junit.reflects.Person");
        System.out.println(c1);
        //2.类名.class
        Class c2 = Person.class;
        System.out.println(c2);
        //3.对象.getClass()
        Person person = new Person();
        Class c3 = person.getClass();
        System.out.println(c3);
    }
}

在这里插入图片描述

  • 需要注意的是：
    一个类在 JVM 中只会有一个 Class 实例，即我们对上面获取的 c1、c2和c3进行 equals 比较，发现都是true。

3.2 Class对象的功能：通过反射获取类属性、方法、构造器

  • 获取功能
  1. 获取成员变量们
Field[] getFields() 获取所有public修饰的成员变量

Field getField(String name) 获取指定名称的public修饰的成员变量

Field[] getDeclareFields() 获取所有的成员变量

Field getDeclaredField(String name) 获取指定的成员变量

具体使用：
创建DemoPersion对象

package junit.reflects;

public class DemoPerson {
    private String name01;
    public String name02;
    String name03;
    protected String name04;
    public String name05;

    public DemoPerson() {
    }

    public DemoPerson(String name01, String name02, String name03, String name04, String name05) {
        this.name01 = name01;
        this.name02 = name02;
        this.name03 = name03;
        this.name04 = name04;
        this.name05 = name05;
    }

    public String getName01() {
        return name01;
    }

    public void setName01(String name01) {
        this.name01 = name01;
    }

    public String getName02() {
        return name02;
    }

    public void setName02(String name02) {
        this.name02 = name02;
    }

    public String getName03() {
        return name03;
    }

    public void setName03(String name03) {
        this.name03 = name03;
    }

    public String getName04() {
        return name04;
    }

    public void setName04(String name04) {
        this.name04 = name04;
    }

    public String getName05() {
        return name05;
    }

    public void setName05(String name05) {
        this.name05 = name05;
    }

    @Override
    public String toString() {
        return "DemoPerson{" +
                "name01='" + name01 + '\'' +
                ", name02='" + name02 + '\'' +
                ", name03='" + name03 + '\'' +
                ", name04='" + name04 + '\'' +
                ", name05='" + name05 + '\'' +
                '}';
    }
}

其中的成员变量：

private String name01;
public String name02;
String name03;
protected String name04;
public String name05;

创建主程序获取DemoPersion的成员变量

package junit.reflects;

import java.lang.reflect.Field;
import java.util.stream.Stream;

public class Demo03 {
    public static void main(String[] args) throws Exception {
        //1.创建Class类对象
        Class c1 =DemoPerson.class;

        //2.通过Class对象获取DemoPerson类的成员变量
        //getFields()获取所有public修饰的成员变量 name02 name05
        Field[] s1 = c1.getFields();
        //getField()获取指定public修饰的成员变量 name05
        Field s2 = c1.getField("name05");
        //getDeclareFields()获取所有成员变量 name01 name02 name03 name04 name05
        Field[] s3 = c1.getDeclaredFields();
        //getDeclareField()获取指定成员变量 name04
        Field s4 = c1.getDeclaredField("name04");

        Stream.of(s1).forEach(System.out::println);
        System.out.println("===========================");
        System.out.println(s2);
        System.out.println("===========================");
        Stream.of(s3).forEach(System.out::println);
        System.out.println("===========================");
        System.out.println(s4);
    }
}

在这里插入图片描述
2. 获取构造方法们

Constructor[] getConstructors();//无参构造
Constructor[] getConstructors(参数1类型.class,参数2类型.class...);//含参构造

Constructor getConstructor();
Constructor getConstructor(参数1类型.class,参数2类型.class...);

Constructor[] getDeclaredConstructors();
Constructor[] getDeclaredConstructors(参数1类型.class,参数2类型.class...);

Constructor getDeclaredConstructor();
Constructor getDeclaredConstructor(参数1类型.class,参数2类型.class...);
  1. 获取成员方法们
Method[] m3 = c1.getMethods();

Method m4 = c1.getMethod(String "方法名",方法参数1类型.class,方法参数2类型.class...);

Method[] m3 = c1.getDeclaredMethods();

Method m4 = c1.getDeclaredMethod(String "方法名",方法参数1类型.class,方法参数2类型.class...);
  1. 获取全类名
Srting getName();
3.3 对获取到的构造方法，成员变量，成员方法的使用
  • 构造方法
  • 创建对象01：构造方法.newInstance
package junit.reflects;

import java.lang.reflect.Constructor;

public class Demo02 {
    public static void main(String[] args) throws Exception {
    	//创建Class对象
        Class c1 = DemoPerson.class;
		//创建含参构造
        Constructor con01 = c1.getConstructor(String.class, String.class, String.class, String.class, String.class);
        //使用newInstance创建对象，添加参数
        Object obj = con01.newInstance("1号","2号","3号","4号","5号");

        System.out.println(obj);
    }
}

在这里插入图片描述

  • 创建对象02：直接class类名.getDeclaredConstructor().newInstance
  • 创建对象03：直接class类名.newInstance(已过时)
  • 成员变量
  • 获取成员变量的值 成员变量.get(类)
  • 设置成员变量的值 成员变量.set(类,值)
  • 暴力反射（修改带修饰符保护的成员）成员变量.setAccessible(true)

成员变量：

private String name01;
public String name02;
String name03;
protected String name04;
public String name05;

主程序：

package junit.reflects;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.stream.Stream;

public class Demo03 {
    public static void main(String[] args) throws Exception {
        //1.创建Class类对象
        Class c1 = DemoPerson.class;
        //2.通过Class对象获取DemoPerson类的成员变量

        //getField()获取指定public修饰的成员变量 name05
        Field s1 = c1.getField("name05");
        //getDeclareField()获取指定成员变量 name04
        Field s2 = c1.getDeclaredField("name04");

        //创建构造方法
        Constructor con = c1.getConstructor();
        Object obj = con.newInstance();

        //使用get与set获取和设置成员变量的值
        s1.set(obj,"5号成员");
        System.out.println(s1);
        System.out.println(s1.get(obj));

        s2.setAccessible(true);//protected保护的成员变量，使用暴力反射
        s2.set(obj,"4号成员");
        System.out.println(s2);
        System.out.println(s2.get(obj));
    }
}

在这里插入图片描述

  • 成员方法
  • 执行方法 ：获取的成员方法.invoke(类,成员方法参数1,成员方法参数2....)

类中的成员方法截取：

public void method01(String name,int age){
    System.out.println("姓名："+name+".年龄："+age);
}

主程序：

package junit.reflects;

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

public class Demo01 {
    public static void main(String[] args) throws Exception {
        Class c1 = DemoPerson.class;

        Method m1 = c1.getMethod("method01", String.class, int.class);

        Constructor con = c1.getConstructor();
        Object obj = con.newInstance();

        m1.invoke(obj,"张三",12);
    }
}

在这里插入图片描述

Mango学习日记
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Junit单元测试、反射
平安
08-22 1233
目录 Junit单元测试 测试分类 Junit使用：白盒测试 反射 反射概念 获取class对象的三种方式  Class对象功能 获取成员变量 获取构造方法 获取成员方法  Junit单元测试 测试分类          1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。          2. 白盒测试：需要写代码。关注程序具体的执行流程。 Juni...
JAVA面向对象编程_孙卫琴（2/5）
04-09
JAVA面向对象编程_孙卫琴 由于太大，分了5个压缩包，如果有需要的，下载齐了5部分后再解压。
java内存 三特性_Java/5_面向对象三大特性.md at master · zm79287/Java · GitHub
weixin_42099936的博客
03-02 71
五、三大特性封装1. 封装概述利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体。数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。用户无需知道对象内部的细节，但可以通过对象对外提供的接口来访问该对象。2. 优点减少耦合：可以独立地开发、测试、优化、使用、理解和修改减轻维护的负担：可以更容易被程序员理解，并且在调试的时候可以...
JUnit单元测试、反射、注解、动态代理
WDNMDnm的博客
01-08 702
【JUnit单元测试、反射、注解、动态代理】 学习目标 能够使用Junit进行单元测试 能够通过反射技术获取Class字节码对象 能够通过反射技术获取构造方法对象，并创建对象。 能够通过反射获取成员方法对象，并且调用方法。 能够通过反射获取属性对象，并且能够给对象的属性赋值和取值。 能够说出注解的作用 能够自定义注解和使用注解 能够说出常用的元注解及其作用 能够解析注解并获取注解中的数据 能够完成注解的MyTest案例 能够说出动态代理模式的作用 能够使用Proxy的方法生成代理对
自学javase的回顾（2/5）
zourenqiang
07-02 183
小白自学javase的回顾（2/5）1、面向对象之封装2、面向对象之继承3、面向对象之多态4、对象的内存图结构5、接口 继续回顾javase的知识，持续更新… 1、面向对象之封装 首先需要复习一下什么是面向对象？ 面向对象就是面向具体的某一类的实例化的产物去处理事务。 创建对象之前要先构造一个类，类就是具有相同属性和方法的抽象成一种类。 类的语法：class 类名{ 属性； 方法； } class Animal{ String name; public static void run(){
junit-platform-engine-1.6.3.jar
01-10
junit-platform-engine-1.6.3.jarjunit-platform-engine-1.6.3.jar
junit-platform-launcher-1.7.0.jar
01-10
junit-platform-launcher-1.7.0.jarjunit-platform-launcher-1.7.0.jar
spring-boot2-junit5-sample：Spring Boot 2 + JUnit 5 + Maven示例应用程序
02-04
将JUnit 5依赖项添加到pom.xml < dependency>< groupId>org.junit.jupiter</ groupId>< artifactId>junit-jupiter-api</ artifactId>< scope>test</ scope></ dependency>< dependency>< groupId>org.junit.jupiter...
Java-Junit-Mockito
03-16
Java-Junit-Mockito 课程概述步骤列表JUnit步骤01：需要单元测试步骤02：设置您的第一个JUnit步骤03：第一个成功的JUnit。 Green Bar和assertEquals步骤04：重构您的第一个JUnit测试步骤05：第二个JUnit示例...
android-junit5:使用Android的JUnit 5进行测试
05-03
android-junit5 一个Gradle插件，允许使用Android Gradle Plugin 3.5.0或更高版本在Android环境中执行测试。 如何？ 该插件为项目的每个构建变体配置单元测试任务，以在JUnit Platform上运行。 此外，它附加到...
JUnit单元测试（五）－－通过反射测试私有方法
thewebcode
04-07 408
JUnit单元测试（五）－－通过反射测试私有方法 测试私有（private）的方法有两种： 1)把目标类的私有方法（修饰符：private）修改为（public），不推荐，因为这样修改了源程序 2)通过反射 （推荐） 假设目标程序： PrivateMethod.java package com.junit3_8; public class PrivateMethod { ...
Java(2012/2/5)
随性
02-05 408
一、enum（枚举）应用的场合：         权限控制：     package com.xyh5; public enum AccessRight {     MANAGER, DEPARTMENT, EMPLOYEE; }   package com.xyh5; public class AccessControl {     public static boolea
java线程总结（2/5）
weixin_33738555的博客
03-26 71
线程基本信息和优先级别 方  法 功        能 isAlive() 判断线程是否还“活”着，即线程是否还未终止。 getPriority() 获得线程的优先级数值 setPriority() 设置线程的优先级数值 setName() 给线程一个名字...
JUnit 5和JUnit 4比较
热门推荐
javaZhong的博客
01-21 2万+
JUnit 5旨在调整java 8样式的编码，并且比JUnit 4更强大和灵活。在这篇文章中，JUnit 5 vs JUnit 4，我们将关注junit 4和junit 5之间的一些主要差异。 1. JUnit 5 vs JUnit 4 - 注释 两个版本中的大多数注释都是相同的，但很少有区别。这是一个快速比较。 特征 JUNIT 4 JUNIT 5 声明一种测试方法 ...
JUnit5常用注解解析（一）
MIT的博客
04-28 5476
1、简介    JUnit5有别与之前的版本，进行了模块化，它由几个不同的模块组成，这些模块分别来自三个不同的子项目：        JUnit5 = JUnit Platform + JUnit Jupiter + JUnitVintage    Junit Platform是在JVM上启动测试框架的基础平台，还定义了TestEngine API，该API可用于开发在平台上运行的测试框架。此外，...
智慧学院智能化项目规划设计方案PPT(45页).pptx
05-03
智慧学院智能化项目规划设计方案PPT(45页).pptx
AO工艺设计计算(全).xls
最新发布
05-03
污水处理计算书
Could not transfer artifact org.apache.maven.surefire:surefire-junit-platform:pom:2.22.2 from/to central (https://repo.maven.apache.org/maven2): Transfer failed for https://repo.maven.apache.org/maven2/org/apache/maven/surefire/surefire-junit-platform/2.22.2/surefire-junit-platform-2.22.2.pom
07-14
这个错误表示 Maven 在下载 `org.apache.maven.surefire:surefire-junit-platform:pom:2.22.2` 这个依赖时出现了问题。具体来说，它无法从 Maven 的中央仓库（https://repo.maven.apache.org/maven2）成功下载该依赖...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值