java 反射和内省

最新推荐文章于 2022-07-17 16:57:44 发布
最新推荐文章于 2022-07-17 16:57:44 发布
阅读量1.7k 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： java（基础知识） 文章标签： java class string object constructor methods
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xxdyynn163/article/details/2622736
本文深入探讨了Java反射和内省机制的核心概念与应用场景，包括动态获取类信息及调用方法的方式。提供了丰富的示例代码，展示了如何利用反射创建对象、获取属性，以及使用内省来获取Bean属性描述。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1       反射和内省

反射 (Reflection) ，JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
内省 (Introspector)，是“看透class”的能力（内省、内观、反省）。
2.1    “Class” object的取得途径
Java允许我们从多种管道为一个class生成对应的Class object。

Class object 诞生管道
示例
运用getClass()
注：每个class 都有此函数
String str = "abc";
Class c1 = str.getClass();
运用
Class.getSuperclass()2
Button b = new Button();
Class c1 = b.getClass();
Class c2 = c1.getSuperclass();
运用static method
Class.forName()
（最常被使用）
Class c1 = Class.forName ("java.lang.String");
Class c2 = Class.forName ("java.awt.Button");
Class c3 = Class.forName ("java.util.LinkedList$Entry");
Class c4 = Class.forName ("I");
Class c5 = Class.forName ("[I");
运用
.class 语法
Class c1 = String.class;
Class c2 = java.awt.Button.class;
Class c3 = Main.InnerClass.class;
Class c4 = int.class;
Class c5 = int[].class;
运用
primitive wrapper classes
的TYPE 语法
 
Class c1 = Boolean.TYPE;
Class c2 = Byte.TYPE;
Class c3 = Character.TYPE;
Class c4 = Short.TYPE;
Class c5 = Integer.TYPE;
Class c6 = Long.TYPE;
Class c7 = Float.TYPE;
Class c8 = Double.TYPE;
Class c9 = Void.TYPE;
图1：Java 允许多种管道生成Class object。
 
以图2的java.util.LinkedList为例，将Java class的定义大卸八块，每一块分别对应图3所示的Reflection API。
 
package java.util;                 //(1)
import java.lang.*;                //(2)
public class LinkedList<E>              //(3)(4)(5)
extends AbstractSequentialList<E>               //(6)
implements List<E>, Queue<E>,
Cloneable, java.io.Serializable              //(7)
{
private static class Entry<E> { … }//(8)
public LinkedList() { … }                  //(9)
public LinkedList(Collection<? extends E> c) { … }
public E getFirst() { … }                  //(10)
public E getLast() { … }
private transient Entry<E> header = …;        //(11)
private transient int size = 0;
}
图2：将一个Java class 大卸八块，每块相应于一个或一组Reflection APIs（图3）。
 
2.3    Java classes 各成份所对应的Reflection APIs
图2的各个Java class成份，分别对应于图3的Reflection API，其中出现的Package、Method、Constructor、Field等等classes，都定义于java.lang.reflect。本表并非Reflection APIs 的全部。

Java class 内部模块（参见图3）
Java class 内部模块说明
相应之Reflection API，多半为Class methods。
返回值类型(return type)
(1) package
class隶属哪个package
getPackage()
Package
(2) import
class导入哪些classes
无直接对应之API。
解决办法见图5-2。
 
(3) modifier
class（或methods, fields）的属性
 
int getModifiers()
Modifier.toString(int)
Modifier.isInterface(int)
int
String
bool
(4) class name or interface name
class/interface
名称getName()
String
(5) type parameters
参数化类型的名称
getTypeParameters()
TypeVariable <Class>[]
(6) base class
base class（只可能一个）
getSuperClass()
Class
(7) implemented interfaces
实现有哪些interfaces
getInterfaces()
Class[]
 
(8) inner classes
内部classes
getDeclaredClasses()
Class[]
(8') outer class
如果我们观察的class 本身是inner classes，那么相对它就会有个outer class。
getDeclaringClass()
Class
(9) constructors
构造函数getDeclaredConstructors()
不论 public 或private 或其它access level，皆可获得。另有功能近似之取得函数。
Constructor[]
(10) methods
操作函数getDeclaredMethods()
不论 public 或private 或其它access level，皆可获得。另有功能近似之取得函数。
Method[]
(11) fields
字段（成员变量）
getDeclaredFields()不论 public 或private 或其它access level，皆可获得。另有功能近似之取得函数。
Field[]
图3：Java class大卸八块后（如图2），每一块所对应的Reflection API。
Model.java
 
package RefInt;
 
import java.io.Serializable;
import java.util.Date;
 
publicclass Model implements Serializable {
 
    privatestaticfinallongserialVersionUID = -162798607158235676L;
 
    publicstatic String id = "111111";
    public String name = "haha";
    privateintage ;
    private Date b;
   
    publicint getAge() {
       returnage;
    }
    publicvoid setAge(int age) {
       this.age = age;
    }
    public Date getB() {
       returnb;
    }
    publicvoid setB(Date b) {
       this.b = b;
    }
    public String getName() {
       returnname;
    }
    publicvoid setName(String name) {
       this.name = name;
    }
}
RefInt.java
 
package RefInt;
 
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
 
publicclass RefInt {
   
    publicstaticvoid main(String[] args) {
       System.out.println("f_1()");
       f_1();
       System.out.println("f_2()");
       f_2();
       System.out.println("f_3()");
       f_3();
       System.out.println("f_4()");
       f_4();
       System.out.println("getArrayByIndex()");
       int[] a = {10,2,3,5};
       String[] s = {"aabc","aaabc","def","f"};
       // 数组排序
       Arrays.sort(s);
       System.out.println(getArrayByIndex(s,0));
       System.out.println(getArrayByIndex(a,0));
       System.out.println(getArrayByIndex(a,3));
       Arrays.sort(a);
       System.out.println(getArrayByIndex(a,0));
       System.out.println(getArrayByIndex(a,3));
       Array.set(a, 0, -1);
       System.out.println(getArrayByIndex(a,0));
    }
 
    /**
     *获得数组o下标为index的值
     *@paramo
     *@paramindex
     *@return
     */
    publicstatic Object getArrayByIndex(Object o , int index) {
       return Array.get(o, index);
    }
   
    /**
     *通过类名得到类描述对象
     *通过类描述对象获得类模式（此类为public）
     */
    publicstaticvoid f_4() {
       try {
           Class class_my = Class.forName("RefInt.Model");
           int m = class_my.getModifiers();
           System.out.println(class_my.getModifiers());
           if (Modifier.isPublic(m))
                System.out.println("public");
 
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       } catch (SecurityException e) {
           e.printStackTrace();
       } catch (IllegalArgumentException e) {
           e.printStackTrace();
       }
    }
   
    /**
     *通过类名得到类描述对象
     *通过类描述对象获得属性对象列表并显示其属性
     */
    publicstaticvoid f_3() {
       try {
           Class class_my = Class.forName("RefInt.Model");
           // 只能得到属性是public的Field
           Field[] publicFields = class_my.getFields();
           for (int i = 0; i < publicFields.length; i++) {
              String fieldName = publicFields[i].getName();
              Class typeClass = publicFields[i].getType();
              String fieldType = typeClass.getName();
              System.out.println("Name: " + fieldName + ", Type: " + fieldType);
           }
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       }
    }
    /**
     *通过实体对象获得类描述对象
     *通过累描述对象获得指定属性对象
     *通过属性对象实例得到属性名和属性值
     */
    publicstaticvoid f_2() {
       Model model = new Model();
       //属性必须是public,否则抛出NoSuchFieldException异常
       String sfiled = "name";
       Class class_my = model.getClass();
       try {
           Field filed = class_my.getField(sfiled);
           System.out.println(filed.getName());
           System.out.println(filed.get(model));
       } catch (SecurityException e) {
           e.printStackTrace();
       } catch (NoSuchFieldException e) {
           e.printStackTrace();
       } catch (IllegalArgumentException e) {
           e.printStackTrace();
       } catch (IllegalAccessException e) {
           e.printStackTrace();
       }
    }
   
    /**
     *通过类名获得实体对象
     *通过属性名称获取实体对象属性值
     */
    publicstaticvoid f_1() {
       try {
           Class cla = Class.forName("RefInt.Model");
           Object o = cla.newInstance();
           String methodName = "getName";
           Method m = cla.getMethod(methodName, (Class[])null);
           System.out.println(m.invoke(o, (Object[])null));
           methodName = "getAge";
           m = cla.getMethod(methodName, (Class[])null);
           System.out.println(m.invoke(o, (Object[])null));
           methodName = "getB";
           m = cla.getMethod(methodName, (Class[])null);
           System.out.println(m.invoke(o, (Object[])null));
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       } catch (InstantiationException e) {
           e.printStackTrace();
       } catch (IllegalAccessException e) {
           e.printStackTrace();
       } catch (SecurityException e) {
           e.printStackTrace();
       } catch (NoSuchMethodException e) {
           e.printStackTrace();
       } catch (IllegalArgumentException e) {
           e.printStackTrace();
       } catch (InvocationTargetException e) {
           e.printStackTrace();
       }
    }
}
 
一般的做法是通过类Introspector来获取某个对象的BeanInfo信息，然后通过BeanInfo来获取属性的描述器（PropertyDescriptor），通过这个属性描述器就可以获取某个属性对应的getter/setter方法，然后我们就可以通过反射机制来调用这些方法。
Intro.java
 
package RefInt;
 
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
 
publicclass Intro {
    publicstaticvoid main(String[] args) {
       Model m = new Model();
       try {
           // 从其所在位置开始停止分析的基类。stopClass 或其基类中的所有方法/属性/事件都将在分析中被忽略。
           BeanInfo beanInfor = Introspector.getBeanInfo(m.getClass(),Object.class);
           PropertyDescriptor[] p = beanInfor.getPropertyDescriptors();
           for(int i=0;i<p.length;i++){
              System.out.println(p[i].getName()+"="+
                      p[i].getReadMethod().invoke(m,(Object[])null));
            }
 
       } catch (IntrospectionException e) {
           e.printStackTrace();
       } catch (IllegalArgumentException e) {
           e.printStackTrace();
       } catch (IllegalAccessException e) {
           e.printStackTrace();
       } catch (InvocationTargetException e) {
           e.printStackTrace();
       }
    }
}
 
java的自省机制_深入理解Java反射机制
weixin_35006125的博客
03-02 1155
前言最近在接触 Android 的组件化原理的时候，发现自己对 Java 反射的机制理解并不是很深，只能利用周末的时间把 Java 反射机制回炉重铸。什么是Java反射反射机制是 Java 语言提供的一种基础功能，赋予了 Java 程序在运行时的自省(introspect，官方用语)的能力。通过 Java 的反射机制，程序员可以在 Java 程序在运行态的时候操作任意的类或者对象的属性、方法。利用...
Java反射与内省-PPT
11-20
Java反射与内省是Java编程语言中的核心特性，它们为开发者提供了强大的能力，可以在运行时检查和操作类、接口、对象及其属性。本PPT深入探讨了这些概念，旨在帮助开发者充分利用Java平台的灵活性。 首先，Java反射...
java语言自省------反射
u010214269的专栏
11-23 1283
第一次去接触反射，感觉很陌生，接触一点后
JAVA的内省机制（introspector）与反射机制（reflection）
zgmzyr的专栏
07-21 7220
 <br />相对而言，反射比内省更容易理解一点。用一句比较白的话来概括，反射就是让你可以通过名称来得到对象 ( 类，属性，方法 ) 的技术，这种技术比内省机制使用范围更广泛。例如我们可以通过类名来生成一个类的实例；知道了方法名，就可以调用这个方法；知道了属性名就可以访问这个属性的值。 内省是 Java 语言对 Bean 类属性、事件的一种缺省处理方法。例如类 A 中有属性 name, 那我们可以通过 getName,setName 来得到其值或者设置新的值。通过 getName/setName 来访问 n
java的反射和内省机制
09-27 2078
前几天看一本提到了JAVA的反射机制,由于过于概念不能很好理解.没想到在网络编程中又碰到了这个问题.看来不能回避了,要好好去学习一下了.反射本身并不是一个新概念，它可能会使我们联想到光学中的反射概念，尽管计算机科学赋予了反射概念新的含义，但是，从现象上来说，它们确实有某些相通之处，这些有助于我们的理解。在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来
Java中的反射和内省简单实例
在风雨中奔跑
05-22 580
1.反射和内省          反射式在运行状态把Java类中的各种成分映射成相应的Java类，可以动态的获取所有的属性以及动态调用任意一个方法，强调的是运行状态。       内省机制是通过反射来实现的，BeanInfo用来暴露一个bean的属性、方法和事件，以后我们就可以操纵该JavaBean的属性。 2.反射和内省的图 一个简
java反射全解（反射原理+反射API详解+反射与数组+反射与泛型+反射源码与性能开销+反射优缺点+反射与内省）
06-21
java 反射机制是 Java 语言中的一种动态获取信息和调用对象方法的技术核心。它允许在程序运行时加载、探索以及使用编译期间完全未知的 .class 文件。通过反射机制，可以在运行时判断任意一个对象所属的类、构造任意...
Java中的内省与反射.doc
最新发布
06-28
反射和内省都是Java中非常强大的特性，能够显著提高程序的灵活性和可扩展性。通过对类和对象的元数据进行操作，这两种技术使得开发者能够在运行时动态地改变程序的行为，这对于构建高度灵活的应用系统至关重要。掌握...
Java反射与内省技术深度解析
资源摘要信息: "Java反射与内省-PPT" ...在本资源中，我们通过详细解析反射机制、注解、动态加载类、以及动态调用对象方法等相关知识点，为理解和应用Java反射与内省提供了充分的理论基础和技术指导。
minimalcode-reflect:JavaBean 的简约反射和内省功能
05-30
在Java编程语言中，反射和内省是两个强大的特性，它们允许程序在运行时检查类、接口、字段和方法的信息，甚至动态地调用方法和访问属性。"minimalcode-reflect"项目提供了一个简约的框架，专注于JavaBean的反射和...
java 反射与内省
qq_45809896的博客
08-25 139
什么叫反射？ JAVA 反射机制是在运行状态中 ， 对于任意一个类 ， 都能够知道这个类的所有属性和方法 ； 对于任意一个对象 ， 都能够调 用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为 java 语言的反射机制。 认识 Class 类 Class 类表示什么？ 很多的人——可以定义一个 Person 类（有年龄，性别，姓名等） 很多的车——可以定义一个 Car 类（有发动机，颜色，车轮等） 很多的类——Class 类 此类是一个最终类，是不允许有子类的，而且此类声明的时候使
Java的反射机制 —— 类的镜子
莪是男神的博客
07-17 787
定义在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于Java语言的反射（Reflection）机制。反射（Reflection）是Java语言的特性之一，能够让Java程序在运行时动态地执行类的方法、构造方法等。可以说有了反射，不管什么类在我们面前都毫无隐私可言，什么private、protected、defaultPerl、Python、Ruby是动态语言，而C++...
Java学习笔记——反射机制
m0_53127728的博客
04-30 772
在编译时，当我们无法得知该对象或类可能属于哪些类，可以使用反射动态获取该对象或者类的信息。
Java反射和内省机制的区别
Jet_Green的博客
08-06 888
很多人了解Java发射机制，但是今天我在学习springIOC（依赖注入）的原理的时候，注意到了一个词叫做内省机制 那么我就在想这个内省机制是什么呢？ WiKi上的解释是： 在计算机科学中，内省是指计算机程序在运行时（Run time）检查对象（Object）类型的一种能力， 通常也可以称作运行时类型检查。 不应该将内省和反射混淆。 相对于内省，反射更进一步， 是指计算机程序在运行时（...
JAVA 反射方法总结
m0_50210478的博客
01-22 329
反射方法总结
JAVA开发的自省
jy317358306的博客
11-24 315
前言 最近身边的各种做技术或者Hr的都面临着面试的问题，技术人员觉得公司对于个人的技术要求越来越高，学习的知识越来越多无法适应；而Hr面临着大批量的技术人员的涌入，无法有效的快速区分出有效的人才以及人才的分级，鉴于此，特地先奉上JAVA知识图谱，知识图谱不全或者有遗漏可以留言讨论。另外也分别给予技术人员对于Java语言学习的规划和Hr对于人才的区分鉴别发表一些我的看法。 JAVA开发的目前情况与远景分析 目前情况 随着社会科技的迅猛发展，IT和互联网开始逐步渗透到普通人生活的方方面面，也正是基于此，程序员
java的自省机制_JAVA内省(自省)机制 ( Introspector , BeanInfo, PropertyDescriptor )
weixin_42131601的博客
03-02 783
目的和作用： 通过内省，获取和操作javaBean中的成员信息(方法，事件，属性)。—————————————————-内省使用的核心类(接口)———————————————————–Java.beans.Introspector –工具类，通过 Introspector 类就可以获取和操作javaBean中的属性、事件和方法。(staticBeanInfo)getBeanInfo(Class...
深入理解Java反射机制
weixin_45189747的博客
11-25 200
前言 最近在接触 Android 的组件化原理的时候，发现自己对 Java 反射的机制理解并不是很深，只能利用周末的时间把 Java 反射机制回炉重铸。 什么是Java反射 反射机制是 Java 语言提供的一种基础功能，赋予了 Java 程序在运行时的自省（introspect，官方用语）的能力。通过 Java 的反射机制，程序员可以在 Java 程序在运行态的时候操作任意的类或者对象的属性、方...
Java反射详解
NaNa
01-27 233
一,反射 –1,概述 Reflection(反射) 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“ 自审”，也有称作“自省”。反射非常强大，它甚至能直接操作程序的私有属性。我们前面学习都有一个概念， private的只能类内部访问，外部是不行的，但这个规定被反射赤裸裸的打破了。 反射就像一面镜子，它可以在运行时获取一个类的所有信息，可以获取到任何定义的信息（包括成员变量，成员方 法，构造器等），并且可以操纵类的字段、方法、构造器等部分。 –2,作用 –
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值