Java反射学习总结

最新推荐文章于 2024-07-24 21:47:59 发布
最新推荐文章于 2024-07-24 21:47:59 发布
阅读量157 收藏
点赞数
分类专栏： Java基础 文章标签： java 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44759105/article/details/110525812
版权

Java反射

文章目录

一、反射是什么？

1.Java反射机制

在程序运行时动态加载类并获取类的详细信息（属性，构造方法，方法等），并且可以操作类或对象的属性和方法。

本质：JVM得到class对象，再通过class对象进行反编译，从而获取对象的各种信息。

反射最重要的用途就是开发各种通用框架。搞懂了反射以后，可以帮助理解框架的一些原理。所以说有一句很经典的话：反射是框架设计的灵魂。

2.Class类

在Java中，一切皆对象。每个具体的类的对象也有很多信息，这些类型信息就通过Class对象表示。其实创建的实例对象就是通过Class对象创建的。

每一种类都有一个Class对象，每当编译产生一个新类，就产生一个Class对象，基本类型有Class对象，数组有Class对象（数组的Class对象：具有相同元素类型和维数的数组都共享一个Class对象，并没有说元素个数）。

Class对象对应java.lang.Class类。

如果说类是对对象的抽象和集合的话，Class类就是对类的抽象和集合。

Class对象没有公共的构造方法，Class对象是在类加载的时候有JVM及通过调用类加载器中的defineClass方法自动构造的，所以不能显式的声明一个Class对象。

二、反射的优缺点

  1. 优点：在运行时获得类的各种内容，进行反编译，对于Java这种先编译再运行的语言，能够让我们很方便的创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码的链接，更加容易实现面向对象。
  2. 缺点：由于反射会额外消耗一定的系统资源，因此如果不需要动态地创建一个对象，那么就不需要用反射。另外，反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题。

三、如何获得Class对象

1.Class.forName(“类路径”)

try {
     Class<?> clazz2=Class.forName("java.lang.String");
     System.out.println(clazz2.getName());
} catch (ClassNotFoundException e) {
     e.printStackTrace();
}

Class.forName方法是Class类的一个静态方法，forName在执行的过程中发现如果类String还没有被加载，那么JVM就会调用类加载器去加载String类，并返回加载后的Class对象。Class对象和其他对象一样，我们可以获取并操作它的引用。

这种是最常用的，第二种都已经产生实例对象了，第三种需要导入包，依赖性强。

2.实例对象.getclass()

String s=new String();
Class<?> clazz=s.getClass();
System.out.println(clazz.getName());

3.类名.class

Class<?> clazz1=String.class;
System.out.println(clazz1.getName());

四、获取类实例及成员

1.创建类的实例对象

  1. 通过Class对象的newInstance()方法创建
Object str=clazz.newInstance();//已经弃用
  1. 先通过Class对象获取Constructor对象，再调用Constructor对象的newInstrance()方法创建对象
try {
	//可以指定构造函数，只需要传入相应的Class对象参数
     Constructor constructor=clazz.getConstructor(String.class);
     //newInstance方法传入构造函数的初始化形参
     Object str2=constructor.newInstance("hello reflection");
     System.out.println(str2);
} catch (NoSuchMethodException e) {
     e.printStackTrace();
} catch (IllegalAccessException e) {
     e.printStackTrace();
} catch (InstantiationException e) {
     e.printStackTrace();
} catch (InvocationTargetException e) {
     e.printStackTrace();
}

2.获取类的构造方法并调用

  1. 获取所有的public的构造方法
    public Constructor[] getConstructors()
  2. 获取所有的构造方法（包括private、public、protected、默认）
    public Constructor[] getDeclaredConstructors()
  3. 获取单个构造方法
    public Constructor getConstructor(Class… parameterTypes)//公有
    public Constructor getDeclaredConstructor(Class… parameterTypes)//公有、私有、受保护、默认
  4. 调用（或暴力调用）构造方法
    通过setAccessible(true)方法忽略掉访问修饰符，再通过Constructor对象的newInstance()创建实例

测试代码：

//（1）、（2）、（3），String类的Class对象
//所有公有方法
        System.out.println("----------所有公有构造方法----------");
        Constructor[] constrArray=clazz.getConstructors();
        for(Constructor constructor:constrArray){
            System.out.println(constructor);
        }

        System.out.println("----------所有构造方法----------");
        Constructor[] constrArray2=clazz.getDeclaredConstructors();
        for(Constructor constructor:constrArray2){
            System.out.println(constructor);
        }

        try {
            System.out.println("----------指定参数公有构造方法----------");
            Constructor constructor=clazz.getConstructor(byte[].class);
            System.out.println(constructor);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }

//结果
----------所有共有构造方法----------
public java.lang.String(byte[])
public java.lang.String(byte[],int,int)
public java.lang.String(byte[],java.nio.charset.Charset)
public java.lang.String(byte[],java.lang.String) throws java.io.UnsupportedEncodingException
public java.lang.String(byte[],int,int,java.nio.charset.Charset)
public java.lang.String(java.lang.StringBuilder)
public java.lang.String(java.lang.StringBuffer)
public java.lang.String(char[],int,int)
public java.lang.String(char[])
public java.lang.String(java.lang.String)
public java.lang.String()
public java.lang.String(byte[],int,int,java.lang.String) throws java.io.UnsupportedEncodingException
public java.lang.String(byte[],int)
public java.lang.String(byte[],int,int,int)
public java.lang.String(int[],int,int)
----------所有构造方法----------
public java.lang.String(byte[])
public java.lang.String(byte[],int,int)
public java.lang.String(byte[],java.nio.charset.Charset)
public java.lang.String(byte[],java.lang.String) throws java.io.UnsupportedEncodingException
public java.lang.String(byte[],int,int,java.nio.charset.Charset)
java.lang.String(char[],int,int,java.lang.Void)
java.lang.String(java.lang.AbstractStringBuilder,java.lang.Void)
public java.lang.String(java.lang.StringBuilder)
public java.lang.String(java.lang.StringBuffer)
java.lang.String(byte[],byte)
public java.lang.String(char[],int,int)
public java.lang.String(char[])
public java.lang.String(java.lang.String)
public java.lang.String()
public java.lang.String(byte[],int,int,java.lang.String) throws java.io.UnsupportedEncodingException
public java.lang.String(byte[],int)
public java.lang.String(byte[],int,int,int)
public java.lang.String(int[],int,int)
----------指定参数公有构造方法----------
public java.lang.String(byte[])

//（4），构建Demo类，并访问其私有构造方法
class Demo{
    private String name;
    private Demo(String name){
        this.name=name;
        System.out.println(name);
    }
}

public class Test {
    public static void main(String[] args){
        Class<?> cls=Demo.class;
        try {
            Constructor constructor=cls.getDeclaredConstructor(String.class);
            constructor.setAccessible(true);//否则报错java.lang.IllegalAccessException
            Object obj=constructor.newInstance("私有");
            System.out.println(obj);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

3.获取类的属性并设置

  1. 获取所有的public的属性
    public Filed[] getFileds()
  2. 获取所有的属性（包括private、public、protected、默认）
    public Filed[] getDeclaredFileds()
  3. 获取单个属性
    public Filed getFiled(String filedname)//公有
    public Filed getDeclaredFiled(String filedname)//公有、私有、受保护、默认
  4. 设置（或暴力设置）属性值
    通过setAccessible(true)方法忽略掉访问修饰符，再通过Constructor对象的set方法设置
    public void set(Object obj,Object value):
    参数说明：1.obj:要设置的字段所在的对象；2.value:要为字段设置的值；

测试代码：

class Demo{
    private String name;
    public Demo(String name){
        this.name=name;
        System.out.println(name);
    }

    @Override
    public String toString() {
        return name;
    }
}

public class Test {
    public static void main(String[] args){
        Class<?> cls=Demo.class;
        try {
            Demo obj=(Demo)cls.getConstructor(String.class).newInstance("设置前");
            Field field=cls.getDeclaredField("name");
            field.setAccessible(true);
            field.set(obj,"设置后");
            System.out.println(obj);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

4.获取类的成员方法并调用

  1. 获取所有的public的方法（包含父类）
    public Method[] getMethods()
  2. 获取所有的成员方法（包括private、public、protected、默认）
    public Method[] getDeclaredMethods()
  3. 获取单个成员方法
    public Method getMethod(String name,Class<?>… parameterTypes)//公有
    public Method getDeclaredMethod(String name,Class<?>… parameterTypes)//公有、私有、受保护、默认
    1.name：方法名；2.parameterTypes：方法形参的Class对象
  4. 调用（或暴力调用）成员方法
    通过setAccessible(true)方法忽略掉访问修饰符，再通过Constructor对象的invoke方法调用
    public Object invoke(Object obj,Object… args)
    1.obj:要调用方法的对象；2.传入方法的参数；

测试代码：

class Son{
    public Son(){
        
    }
    private void fun3(){
        System.out.println("子类私有方法");
    }
    public void fun4(){
        System.out.println("子类公有方法");
    }
}
public class Test1 {
    public static void main(String[] args){
        Class clazz=Son.class;
        try {
            Object obj=clazz.getConstructor().newInstance();
            Method method=clazz.getMethod("fun4");
            method.setAccessible(true);
            method.invoke(obj,null);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}

4.反射子类信息时父类信息如何获取？
对Method、Field、Constructor的获取是类似的。
拿Method举例：

  • getMethods()获取所有公有方法，包括父类的公有方法
  • getDeclaredMethods()获取子类的所有方法，但不包括父类的

如果想获取父类所有信息，可以通过getSuperClass()获取父类Class对象，再通过它反射获取信息。
测试代码：

class Father{
    public int x;
    private int y;
    private void fun1(){
        System.out.println("父类私有方法");
    }
    public void fun2(){
        System.out.println("父类公有方法");
    }
}
class Son extends Father{
    public Son(){

    }
    private void fun3(){
        System.out.println("子类私有方法");
    }
    public void fun4(){
        System.out.println("子类公有方法");
    }
}
public class Test1 {
    public static void main(String[] args){
        Class clazz=Son.class;
        Class cla=clazz.getSuperclass();
        System.out.println("----------公有方法---------");
        Method[] methods=clazz.getMethods();
        for(Method method:methods){
            System.out.println(method);
        }

        System.out.println("----------所有方法---------");
        Method[] methods2=clazz.getDeclaredMethods();
        for(Method method:methods2){
            System.out.println(method);
        }
    }
}

结果：

----------公有方法---------
public void Son.fun4()
public void Father.fun2()
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
----------所有方法---------
private void Son.fun3()
public void Son.fun4()

五、反射的其它使用

1.创建数组
Java中数组由一个Object引用。

	try {
            Class clazz=Class.forName("java.lang.String");
            Object array= Array.newInstance(clazz,10);
            Array.set(array,0,"0");
            Array.set(array,1,"1");
            Array.set(array,2,"2");
            Array.set(array,3,"3");
            System.out.println(Array.get(array,2));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

2.调用main方法

  • 1.5：public Object invoke(Object obj,Object…args)
  • 1.4：public Object invoke(Object obj,Object[] args)

JDK1.4和JDK1.5的invork方法有一些区别，所以在反射类似于main(String[] args)这种参数为数组的方法时，又有特殊处理。

当把一个字符串数组作为参数传递给invoke方法时，jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理。
在jdk1.4中当传入数组时，会把这个数组拆成单个作用为参数，就会报错

java.lang.IllegalArgumentException: argument type mismatch

解决方法：

  1. method.invoke(null,new Object[]{new String[]{“xxx”}});
    按jdk1.4语法拆开后仍然是String数组，类型就匹配了。

  2. method.invoke(null,(Object)new String[]{“xxx”});
    相当于传入参数是一个对象，不会拆开

class Demo2{
    public static void main(String[] args){
        System.out.println("reflect main");
    }
}

public class Test2 {
    public static void main(String[] args){
        try {
            Class clazz=Class.forName("Demo2");
            Method method=clazz.getMethod("main",String[].class);
            //invoke第一个参数是实例对象，由于是static方法，所以可以是null
            method.invoke(null,(Object)new String[]{"aaa","bbb"});
            method.invoke(null,new Object[]{new String[]{"aaa","bbb"}});
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

3.通过反射越过泛型检查
由于在编译后，List< String>中的String会擦除为它的父类，这里就是Object，所以在运行时，可以通过反射获取add方法并添加Integer对象。

//在List<String>中添加Integer类实例
		List<String> list=new ArrayList<>();
        list.add("1");
        list.add("2");

        Class cla=list.getClass();
        try {
            Method m=cla.getMethod("add",Object.class);
            m.invoke(list,123);
            for(Object obj:list)
                System.out.println(obj);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

六、参考

https://www.jianshu.com/p/58976c8bf1e1
https://blog.csdn.net/mcryeasy/article/details/52344729
https://blog.csdn.net/qq_32452623/article/details/54025185
https://blog.csdn.net/ju_362204801/article/details/90578678
https://www.sczyh30.com/posts/Java/java-reflection-1/

小森、
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
反射：用于解析类，通过字节码对象生成实例对象的过程（运行时期）
qq_45453185的博客
01-09 760
例一代码： package cn.tedu.reflect; import java.util.List; public class ClassDemo1 { public static void main(String[] args) throws ClassNotFoundException { //1.类名.class—字节码对象 /* Class clz=String.class; ...
Java反射基础学习总结
weixin_46078499的博客
04-21 303
一、反射的概述 什么是反射 Reflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期间借助Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。 反射就是把java类中的各种成分映射成一个个的Java对象 加载完类之后，在堆内的方法区中就产生了一个Class类型的对象，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构，例如：一个类里有成员变量，方法，包等信息，通过反射可以把类中的个个组成信息映射为对象。 注：一个类在内存中只有
第1关：3种方式获取类class字节码对象
m0_65745343的博客
06-10 275
第1关：3种方式获取类class字节码对象
初步了解,如何获取字节码对象和构造器
Bowl_IronMan的博客
09-06 236
字节码对象和构造器的获取
面向对象2
qq_55674489的博客
05-25 247
对象与引用 前面我们也讲过，Java中的变量分为基本类型和引用类型，而Java中的对象正是通过引用对其操作的。 举个例子： class Car{ int money; String name; } Car c1=new Car(); 这条语句就是简单的创建了一个对象。而这其中，其实包含了三个动作。 1.等号左边Car c1指的是创建了一个Car类型的一个引用变量。而c1 便是对象名称。 2.等号右边new Car() 其实是以Car类为模板，在堆
JVM-对象的实例化内存布局与访问定位
weixin_43424751的博客
06-20 133
一，对象的实例化 1. 从字节码角度看待对象的创建过程 new:判断对象对应的类是否加载，如果否，就加载。并在堆中开辟对象空间。 dup：复制引用。 invokespecial:调用Object当中的init方法。 astore_1:将操作数栈中的变量取出放到对应的局部变量表中。 2. 从执行步骤角度看待对象的创建过程 具体过程见上述图片 判断对象对应的类是否加载、链接、初始化： 虚拟机遇到一条new指令，首先去检查这个指令的参数能否在Metaspace的常量池中定位到一个类的符号引用，并且检查这个符号
Java的反射学习总结
AtlantisChina
11-19 189
Java中的反射概念是一个很重要的知识点，它是框架设计的灵魂。
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
JAVA反射知识点总结
12-22
本文介绍了JAVA反射类的基本概念，欢迎阅读学习，一起进步。 文章目录一.反射的基本概念二.反射常用类三.使用反射的基本步骤四.Class类讲解（1）Class类是反射机制的起源和入口（2）Class类存放类的结构信息（3）...
Java反射机制的学习总结
09-05
总的来说，java反射机制是一个很好用的东西，用它可以解决很多死的东西，因为反射机制的灵活行很大，有了他，我们就不要花太多的时间来写操做数据库的代码了，而是方法更多的时间在项目的逻辑功能上，这个可以很大的...
Java反射中java.beans包学习总结
08-28
Java反射中java.beans包学习总结 Java反射中java.beans包是一个非常重要的包，提供了许多有用的工具类和接口，帮助我们更好地实现Java对象的反射操作。本篇文章将通过学习Java反射中java.beans包，总结出相关的知识...
java中反射知识总结
12-15
Java中的反射机制是Java语言一...通过学习和理解Java反射，开发者可以编写出更加灵活、可扩展的代码，解决一些常规编程方式无法处理的问题。但同时，也需要注意其带来的安全性和性能问题，合理地在项目中使用反射技术。
Java通过File获取Class字节码并构造Class对象
过了这个村没这个老王的博客
11-21 1331
java class 转byte[]，再通过class loader加载
如何得到各个字节码对应的实例对象（ Class类型）
Happy learning
06-18 196
  类名.class，例如，System.class 对象.getClass()，例如，new Date().getClass() Class.forName("类名")，例如，Class.forName("java.util.Date");
Java练习题3-面向对象（含解析）
m0_69528918的博客
05-06 5465
🥪🥪🥪各位好，我是小饼干🍪，一个编程界的小学生，每天都希望学习一点点编程相关。最近在CSDN上看到好多的小伙伴都在学java，今天我分享一些习题供大家巩固一下知识，，有些题附上我自己的一些见解，感谢各位的驻足，笔芯♥。 2、下列关于面向对象的说法中，错误的是（ ） A、面向对象思想编程，不仅增强代码了复用性，提供了开发效率，而且为程序的修改补充提供了便利。 B、面向对象就是分析解决问题所需要的步骤，然后用函数把这些步骤一一实现，使用的时候一个一个依次调用。 C、面向对象是把解决的问题按照一定规则划.
java多线程（第二种方式）
u010075989的专栏
12-17 281
实现runnable接口。 class Demo implements Runnable{ private String name; Demo(String name){ this.name = name; } public void run(){ for(int x=1;x<=2
反射获取字节码文件的三种方式
Fzxey的博客
05-10 1006
文章目录反射获取字节码文件的三种方式方式一方法二方法三 反射获取字节码文件的三种方式 Class类：对Class文件的一种描述 反射：通过Class来获取字节码文件对象，使用字节码文件对象来获取类的一些描述信息 方式一 Object的getClass方法 public class Test { public static void main(String[] args) throws ...
JavaEE进阶(17) 通过Class字节码对象获取构造方法创建对象
郑清
09-16 1372
/** * Class字节码对象获取构造方法创建对象 * @author 郑清 */ public class Demo { public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccess...
golang 接口
最新发布
m0_70982551的博客
07-24 966
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Java反射机制详解：功能与应用探索
Java反射机制是Java编程语言提供的一...总结来说，Java反射机制是Java编程中的一个重要特性，它扩展了程序的动态性和可扩展性，是现代软件开发中不可或缺的一部分。掌握好反射，可以极大地提升代码的灵活性和可维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值