Java反射学习笔记

最新推荐文章于 2024-05-27 20:55:58 发布
最新推荐文章于 2024-05-27 20:55:58 发布
阅读量344 收藏
点赞数 2
分类专栏： Java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40613029/article/details/107727837
版权

文章目录

Java反射机制

一、概述

  1. 概述

    • Reflection(反射)是被视为动态语言的关键，反射机制允许程序在执行期间借助Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法
    • 加载完类之后，在堆内存的方法区中就产生一个Class类型的对象(一个类只有一个Class对象)，这个对象就包含了完整的类的内部结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射

  2. 相关API

    • java.lang.Class:代表一个类
    • java.lang.reflect.Method:代表类的方法
    • java.lang.reflect.Field:代表类的成员变量
    • java.lang.reflect.Constructor:代表类的构造器
    • ……

  3. 入门举例

    /**
 * @Description TODO
 * @Author YunShuaiWei
 * @Date 2020/6/11 19:23
 * @Version
 **/
public class ReflectionTest {
    @Test
    public void test1() {
        Person p1 = new Person("Tom", 1);
        p1.age = 10;
        System.out.println(p1.toString());
        p1.show();
    }

    @Test
    public void test2() throws Exception {
        Class clazz = Person.class;
        Constructor con = clazz.getConstructor(String.class, int.class);
        Object tom = con.newInstance("Tom", 10);
//        System.out.println(tom.toString());
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(tom, "Marry");
//        System.out.println(tom.toString());
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        String nation = (String) showNation.invoke(tom, "Chain");
        System.out.println(nation);
    }
}

二、Class类的理解

  • 程序经过javac.exe命令，生成一个或多个字节码文件

  • java.exe命令对某个字节码文件进行解释运行，相当于将字节码文件加载到内存，加载到内存中的类称为运行时类

  • 运行时类作为Class的一个实例

  • 获取Class实例的方式

    public class ClassTest {
    @Test
    public void test() throws ClassNotFoundException {
        Class<Person> clazz1 = Person.class;
        Person p = new Person();
        Class<? extends Person> clazz2 = p.getClass();
        Class<?> clazz3 = Class.forName("ysw.Person");
        System.out.println(clazz1 == clazz2);//true
        System.out.println(clazz1 == clazz3);//true
        System.out.println(clazz2 == clazz3);//true
    }
}

三、类加载器

3.1 概述

  • 类加载器的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口
  • 类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载(缓存)一段时间。

3.2 分类

  • 引导类加载器：用C++编写，是JVM自带的类加载器，负责Java平台核心库，用来加载核心类库，该类无法直接获取
  • 扩展类加载器：负责jre/lib/ext目录下的jar包或-D java.ext.dirs指定目录下的jar包装入工作库
  • 系统类加载器：负责java -classpath或-D java.class.path所指的目录下的类与jar包装入工作，是最常用的类加载器
public class ClassLoaderTest {
    @Test
    public void test() {
        //自定义类，使用系统类加载器加载
        ClassLoader loader = ClassLoaderTest.class.getClassLoader();
        //调用系统类加载器的getParent()：获取扩展类加载器
        ClassLoader parent = loader.getParent();
        //调用扩展类加载器的getParen()：无法获取引导类加载器
        //引导类加载器负责加载Java核心类库，无法加载自定义类
        ClassLoader p = parent.getParent();
        System.out.println(loader);//sun.misc.Launcher$AppClassLoader@58644d46
        System.out.println(parent);//sun.misc.Launcher$ExtClassLoader@61a52fbd
        System.out.println(p);//null
    }
}

四、运行时类对象

  • newInstance()：调用此方法，创建对应的运行时类的对象，内部调用运行时类的空参构造器
  • 要正常运行此方法，运行时类必须提供空参的构造器，空参构造器访问权限通常为public
  • Javabean要求提供一个public的空参构造器，原因是便于通过反射创建对象
public class NewInstanceTest {
    @Test
    public void test() throws IllegalAccessException, InstantiationException {
        Class<Person> clazz = Person.class;
        //创建对象的运行时类的对象，内部调用类的空参构造器
        Person p = clazz.newInstance();
    }
}

五、运行时类完整结构

public class ClassTest {
    //获取属性
    @Test
    public void getFieldTest() {
        Class<Person> clazz = Person.class;
        //getFields：获取当前运行时类及其父类中声明为public访问权限的属性
        Field[] fields = clazz.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println();
        //getDeclaredFieldsL：获取当前类中声明的所有属性(包括private)，不包含父类中的属性
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field field : declaredFields) {
            System.out.println(field);
        }
        System.out.println();
        Field[] field = clazz.getDeclaredFields();
        for (Field f : field) {
            //获取权限修饰符
            int i = f.getModifiers();
            System.out.println("权限修饰符：" + Modifier.toString(i));
            //数据类型
            Class<?> type = f.getType();
            System.out.println("数据类型：" + type);
            //变量名
            String name = f.getName();
            System.out.println("变量名：" + name);
        }
    }

    //获取方法
    @Test
    public void getMethodTest() {
        Class<Person> clazz = Person.class;
        //getMethods()：获取当前类及其父类所有声明为public的方法
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println();
        //getDeclaredMethods()：获取当前类声明的所有方法(包括私有)，不包含父类的方法
        Method[] methods1 = clazz.getDeclaredMethods();
        for (Method method : methods1) {
            System.out.println(method);
        }
        System.out.println();
        Method[] methods2 = clazz.getDeclaredMethods();
        for (Method method : methods2) {
            //获取权限修饰符
            int i = method.getModifiers();
            System.out.println("权限修饰符：" + Modifier.toString(i));
            //获取返回值类型
            Class<?> returnType = method.getReturnType();
            System.out.println("返回值类型：" + returnType);
            //获取方法名
            String name = method.getName();
            System.out.println("方法名：" + name);
            Class<?>[] types = method.getParameterTypes();
            for (Class<?> type : types) {
                System.out.println(name + "方法的参数类型：" + type);
            }
            System.out.println();
        }

    }

    @Test
    public void getConstructorTest() {
        Class<Person> clazz = Person.class;
        //getConstructors()：获取当前类中声明为public的构造器
        Constructor<?>[] constructors = clazz.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println();
        //getDeclaredConstructors()：获取当前类中的所有构造器
        Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }
    }

    //获取运行时类的父类
    @Test
    public void getSuperClassTest() {
        Class<Person> clazz = Person.class;
        //getSuperclass()：获取运行时类的父类
        Class<? super Person> superclass = clazz.getSuperclass();
        System.out.println(superclass);//class java.lang.Object
    }

    //获取当前类所实现的接口
    @Test
    public void getInterfaceTest() {
        Class<Person> clazz = Person.class;
        //getInterfaces()：获取当前类所实现的接口
        Class<?>[] interfaces = clazz.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println("当前类所实现的接口：" + anInterface);//interface java.io.Serializable
        }
    }

    //获取当前类所在的包
    @Test
    public void getPackageTest() {
        Class<Person> clazz = Person.class;
        //获取当前类所在的包
        Package aPackage = clazz.getPackage();
        System.out.println("当前类所在的包："+aPackage);//package ysw
    }
}

六、获取类的指定结构

  • 获取属性
    @Test
    public void testField() throws Exception {
        Class<Person> clazz = Person.class;
        Person p = clazz.newInstance();
        //获取指定属性，该属性需要声明为public
        Field age = clazz.getField("age");
        //获取指定名的属性，包括私有结构
        Field nation = clazz.getDeclaredField("nation");//该属性nation为私有属性
        //保证当前属性可访问
        nation.setAccessible(true);
        //设置指定对象的属性值
        nation.set(p, "Chain");
        String s = (String) nation.get(p);
        System.out.println(s);
        //设置当前对象的属性值
        age.set(p, 18);
        //获取当前对象的属性值
        int pAge = (int) age.get(p);
        System.out.println(pAge);//18
    }
  • 获取方法
@Test
public void testMethod() throws Exception {
    Class<Person> clazz = Person.class;
    Person p = clazz.newInstance();
    //获取指定方法，参数1为方法名，参数2为该方法的形参列表
    Method show = clazz.getDeclaredMethod("show", String.class);
    //保证当前方法可访问
    show.setAccessible(true);
    //调用该方法，参数1为方法的调用者，参数2给当前方法的参数赋值
    String chain = (String) show.invoke(p, "Chain");//invoke的返回值即为对应方法的返回值
    System.out.println(chain);//null，该方法没有返回值
    //获取静态方法run()
    Method run = clazz.getDeclaredMethod("run");
    run.setAccessible(true);
    //调用该方法
    String invoke = (String) run.invoke(Person.class);
    System.out.println(invoke);
}
ysw！不将就
关注
专栏目录
java反射实现接口_Java反射学习笔记
weixin_36354965的博客
02-25 1894
非原创：以下内容都是学习Java反射时从网上摘录的信息汇总Java反射机制可以让我们在编译期(Compile Time)之外的运行期(Runtime)检查类，接口，变量以及方法的信息。反射还可以让我们在运行期实例化对象，调用方法，通过调用get/set方法获取变量的值。下面是一个Java反射的简单例子：Method[] methods = MyObject.class.getMethods();f...
java反射为什么消耗资源_java反射学习笔记（一）——反射概述
weixin_30199299的博客
02-27 1176
[TOC]反射是什么？反射(Reflaction in action )是java的高级特性，反射机制是指在运行状态下，对于任何一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性。这种动态获取信息以及动态调用对象方法的功能就叫做java的反射机制。为什么要使用反射？首先我们要知道java的编译类型有两种，一种是静态编译，也就是在编译时确定类型，绑定对象；一...
第二十三章 Java反射学习笔记
你好, 我在学java的博客
01-03 2356
2.1 反射相关的主要类4.1 Class类常用方法5. 获取类结构信息。
Java 反射学习笔记
djnz56261的博客
12-20 115
反射 由.class反编译为 .java文件 转载于:https://www.cnblogs.com/smartwen666/p/8075033.html
Java反射（个人学习笔记）
最新发布
Rsecret的博客
05-27 1445
Java反射是指在运行时动态地获取类的信息，并可以通过该信息来操作类或对象。通过反射，我们可以在运行时获取类的字段、方法、构造函数等信息，并能够动态地创建对象、调用方法、访问和修改字段的值。
Java反射基础学习笔记
qq_36722262的博客
01-22 1018
Java反射要学习哪些内容，其实要知道的东西很少，也很简单掌握。主要如下：第一部分就是要理解什么是反射。只需要知道反射可以获取类的全部信息，其主要也是用来获取类的全部信息。第二就是会使用反射。包括如何获取反射类、构造函数、成员变量、成员函数、注解等，以及一些常用方法的使用。
Java学习笔记
Piglett的博客
12-30 1102
随着后续的学习还会不断地更新，并不仅仅包含Java基础，后续还会更新SSM，MySQL等内容。其记录了Java基础的学习内容，主要包括24集合到30动态代理（见语雀目录）。希望这篇笔记能够帮助到Java的学习，方便快速进行回顾复习。
Java 学习笔记
weixin_42098295的博客
05-13 2021
Java 是一种面向对象的编程语言，广泛应用于开发各种应用程序，包括 Web 应用程序、桌面应用程序、移动应用程序和嵌入式系统。Java 中有八种基本数据类型：byte、short、int、long、float、double、char 和 boolean。集合用于存储和组织数据。Java 中有各种控制流语句，用于控制程序流程，例如 if-else 语句、switch 语句和循环语句。Java 中有各种运算符，用于执行算术运算、比较运算、逻辑运算和位运算。I/O 用于从文件、网络和其他来源读取和写入数据。
B站韩顺平java学习笔记（二十二）-- 反射 章节
LW_20180806的博客
05-01 1974
一 反射机制 二 Class类 三 类加载 四 反射获取类的结构信息 五 反射相关类 六 反射调用性能优化 七 Class类常用方法
Java，从网络URL中下载文件并保存到本地
！不将就的博客
11-02 5572
Java，从网络URL中下载文件并保存到本地 1. 代码演示 创建Maven项目，导入Hutool工具包 <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>5.4.5</version> </dependency> 代码 import cn.hutool.c
Java，JVM虚拟机详解，JVM从入门到了解
！不将就的博客
06-07 2358
文章目录JVM概述及类加载子系统一、概述1.1. 虚拟机1.2. Java虚拟机1.2.1 概述1.2.2 作用二、JVM的整体结构三、JVM架构模型四、JVM生命周期4.1. 虚拟机的启动4.2. 虚拟机的执行4.3. 虚拟机的退出五、类加载过程5.1. 加载5.2. 链接5.2.1 验证(Verify)5.2.2 准备(Prepare)5.2.3 解析3. 初始化六、类加载器分类6.1. 启动类加载器6.2. 扩展类加载器6.3. 应用程序类加载器七、双亲委派机制7.1 概述7.2 工作原理7.3 优势
Java替换或删除字符串中的指定字符
！不将就的博客
09-09 1473
1. 代码演示 public class TestDemo { @Test public void test() { //需要替换的字符串 String target = "验证码:${code},您正在登录管理后台，5分钟内输入有效。"; //正则表达式 String regEx = "[$]"; //替换之后的新字符 String replace = ""; Patt
RabbitMQ快速入门 学习笔记
！不将就的博客
03-27 962
MQ本质上是一个队列，FIFO先入先出原则。只不过队列中存放的内容是message而已。还是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ是一种非常常见的上下游“逻辑解耦+物理解耦”的消息通信服务。使用MQ之后，消息发送上游只需要依赖MQ，不用依赖其他服务。默认情况下RabbitMQ退出或由于某种原因崩溃时，它忽略队列和消息，除非告知它不要这样做。确保消息不会丢失需要做两件事：我们需要将队列和消息都标记为持久化。
Java多线程学习笔记，超详细
！不将就的博客
11-10 689
多线程 一、基本概念 1、程序 概念：为了完成特定的任务，用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象 2、进程 概念：是程序的执行过程，或是正在运行中的程序。是一个动态的过程：有它自身的产生、存在、消亡过程。 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。 3、线程 概念：进程可进一步细化为线程，是一个程序内部的一条执行路径。 若一个进程同一时间并...
Java蓝桥杯基础练习2n皇后问题
！不将就的博客
03-24 687
问题描述 给定一个n*n的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后和n个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一条对角线上，任意的两个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法？n小于等于8。 输入格式 输入的第一行为一个整数n，表示棋盘的大小。 接下来n行，每行n个0或1的整数，如果一个整数为1，表示对应的位置可以放皇后，如果一个整数为0，表...
Java单例模式---饿汉式，懒汉式，双重校验锁
！不将就的博客
05-17 668
单例模式 一、概述 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式 二、单例设计模式(Singleton) 采取一定的方法保证在软件系统中对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如果我们让类在虚拟机中只产生一个对象，首先必须将类的构造器私有化(private)，这样就不能用new操作符在类的外部产生该类的对象，但在类的内部仍可以产生类的对象。因为在类的外部开始无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只
Spring学习笔记
！不将就的博客
07-04 664
Spring 一、概述 Spring是分层的Java SE/EE应用full-stack轻量级开源框架，以IoC(Inverse Of Control；反转控制)和AOP(Aspect Oriented Programming；面向切面编程)为内核，提供了展现层Spring MVC和持久层Spring JDBC以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE企业应用开源框架 二、体系结构 核心容器：核心容器由spring-core，
Java学习笔记：王重东的编程心得
2. **反射执行**：Java反射机制允许在运行时动态地获取类的信息并操作类的对象。通过`Class`类可以获取类的信息，`Constructor`、`Method`和`Field`类分别用于访问构造器、方法和字段。反射执行可以用于动态调用方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ysw！不将就

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值