JAVA reflect (反射) 分析类结构

最新推荐文章于 2022-11-14 18:17:56 发布
最新推荐文章于 2022-11-14 18:17:56 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： Language Java 文章标签： reflect
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tterminator/article/details/51249754
版权

一、数据准备

Java反射分析用到的Human类

package ReflectAnalysis;

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

    public Human(String name, int age){
        this.name = name;
        this.setAge(age);
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

二、反射分析类域

以name域为例：

public String name;

其中，反射分析如下
1. 获取JAVA修饰符，如 public、protected、final、static等，java reflect api：

Modifier.toString(fields[i].getModifiers())

其中fields[i].getModifiers()获得以整数形式返回的该 Field 对象表示的字段的 Java 语言修饰符。 Modifier.toString()方法返回Java 语言修饰符的字符串形式。

  1. JAVA API对修饰符的说明：修饰符由 Java 虚拟机的 public、protected、private、final、static、abstract 和 interface 对应的常量组成；它们应当使用 Modifier 类的方法来解码。

  2. 当有多个修饰符修饰变量时，Field对象的getModifiers返回的整数值不同，例如当修饰符只有public时，返回值为1；当修饰符为public static时，返回值为9。JDK源码中对返回值的定义如下

    /*
 * Access modifier flag constants from <em>The Java Virtual
 * Machine Specification, Second Edition</em>, tables 4.1, 4.4,
 * 4.5, and 4.7.
 */
/**
 * The <code>int</code> value representing the <code>public</code> 
 * modifier.
 */    
public static final int PUBLIC           = 0x00000001;
/**
 * The <code>int</code> value representing the <code>private</code> 
 * modifier.
 */    
public static final int PRIVATE          = 0x00000002;
/**
 * The <code>int</code> value representing the <code>protected</code> 
 * modifier.
 */    
public static final int PROTECTED        = 0x00000004;
/**
 * The <code>int</code> value representing the <code>static</code> 
 * modifier.
 */    
public static final int STATIC           = 0x00000008;
/**
 * The <code>int</code> value representing the <code>final</code> 
 * modifier.
 */    
public static final int FINAL            = 0x00000010;
/**
 * The <code>int</code> value representing the <code>synchronized</code> 
 * modifier.
 */    
public static final int SYNCHRONIZED     = 0x00000020;
/**
 * The <code>int</code> value representing the <code>volatile</code> 
 * modifier.
 */    
public static final int VOLATILE         = 0x00000040;
/**
 * The <code>int</code> value representing the <code>transient</code> 
 * modifier.
 */    
public static final int TRANSIENT        = 0x00000080;
/**
 * The <code>int</code> value representing the <code>native</code> 
 * modifier.
 */    
public static final int NATIVE           = 0x00000100;
/**
 * The <code>int</code> value representing the <code>interface</code> 
 * modifier.
 */    
public static final int INTERFACE        = 0x00000200;
/**
 * The <code>int</code> value representing the <code>abstract</code> 
 * modifier.
 */    
public static final int ABSTRACT         = 0x00000400;
/**
 * The <code>int</code> value representing the <code>strictfp</code> 
 * modifier.
 */    
public static final int STRICT           = 0x00000800;
// Bits not (yet) exposed in the public API either because they
// have different meanings for fields and methods and there is no
// way to distinguish between the two in this class, or because
// they are not Java programming language keywords
static final int BRIDGE    = 0x00000040;
static final int VARARGS   = 0x00000080;
static final int SYNTHETIC = 0x00001000;
static final int ANNOTATION= 0x00002000;
static final int ENUM      = 0x00004000;
  3. Modifier.toString()源码如下： 
    public static String toString(int mod) {
    StringBuffer sb = new StringBuffer();
    int len;
    if ((mod & PUBLIC) != 0)    sb.append("public ");
    if ((mod & PROTECTED) != 0) sb.append("protected ");
    if ((mod & PRIVATE) != 0)   sb.append("private ");
    /* Canonical order */
    if ((mod & ABSTRACT) != 0)  sb.append("abstract ");
    if ((mod & STATIC) != 0)    sb.append("static ");
    if ((mod & FINAL) != 0)     sb.append("final ");
    if ((mod & TRANSIENT) != 0) sb.append("transient ");
    if ((mod & VOLATILE) != 0)  sb.append("volatile ");
    if ((mod & SYNCHRONIZED) != 0)  sb.append("synchronized ");
    if ((mod & NATIVE) != 0)    sb.append("native ");
    if ((mod & STRICT) != 0)    sb.append("strictfp ");
    if ((mod & INTERFACE) != 0) sb.append("interface ");
    if ((len = sb.length()) > 0)    /* trim trailing space */
        return sb.toString().substring(0, len-1);
    return "";
    }

2.获取域数据类型

fields[i].getType().getName();

3.Field域反射分析代码

public static void printFields(Class<?> classobj){
        System.out.println("    //Fileds");
        String modifier = "";
        String type = "";
        String name = "";
        Field [] fields = classobj.getDeclaredFields();
        for(int i = 0; i <= fields.length - 1; i++){
            modifier = Modifier.toString(fields[i].getModifiers());
            type = fields[i].getType().getName();
            name = fields[i].getName();
            System.out.println("    " + modifier + " " + type + " " + name + ";");
        }
        System.out.println();
    }

三、反射分析类方法

以如下方法为例

public void setAge(int age) {
        this.age = age;
    }

1.获取JAVA修饰符
参照第二部分的反射分析类域中内容。
2.获取方法的返回值

methods[i].getReturnType().getName();

3.获取方法的参数

Class [] paraClasses = methods[i].getParameterTypes();

4.Method方法反射分析代码

public static void printMethods(Class<?> classobj){
        System.out.println("    //Methods");
        String modifier = "";
        String returnType = "";
        String name = "";
        Class [] paraClasses = null;
        StringBuffer paraType = new StringBuffer();
        Method [] methods = classobj.getDeclaredMethods();
        for(int i = 0; i <= methods.length - 1; i++){
            modifier = Modifier.toString(methods[i].getModifiers());
            returnType = methods[i].getReturnType().getName();
            name = methods[i].getName();
            paraClasses = methods[i].getParameterTypes();
            for(int j = 0; j <= paraClasses.length - 1; j++){
                if(j != paraClasses.length - 1){
                    paraType.append(paraClasses[j].getName() + ", ");
                }
                else{
                    paraType.append(paraClasses[j].getName());
                }
            }
            System.out.println("    " + modifier + " " + returnType + " " + name + "(" + paraType.toString() + ")");
        }
        System.out.println();
    }

四、反射分析类构造器方法

参照第三部分反射分析类方法。
构造器方法反射分析代码

public static void printConstructors(Class<?> classobj){
        System.out.println("    //Constructors");
        Constructor [] constructors = classobj.getConstructors();
        String modifier = "";
        String name = "";
        Class [] paraClasses = null;
        StringBuffer paraType = new StringBuffer();
        for(int i = 0; i <= constructors.length - 1; i++){
            modifier = Modifier.toString(constructors[i].getModifiers());
            name = constructors[i].getName();
            paraClasses = constructors[i].getParameterTypes();
            for(int j = 0; j <= paraClasses.length - 1; j++){
                if(j != paraClasses.length - 1){
                    paraType.append(paraClasses[j].getName() + ", ");
                }
                else{
                    paraType.append(paraClasses[j].getName());
                }
            }
            System.out.println("    " + modifier + " " + name + "(" + paraType.toString() + ")");
        }
        System.out.println();
    }

五、程序完整测试代码

package ReflectAnalysis;

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

public class ClassReflectAnalysis {

    public static void main(String[] args) {
        Class<Human> classobj = Human.class;

        String parentName = classobj.getSuperclass().getName();
        String modifier = Modifier.toString(classobj.getModifiers());
        Class [] interfaces = classobj.getInterfaces();
        StringBuffer interfacesBuf = new StringBuffer();
        if(interfaces.length != 0){
            interfacesBuf.append("implements ");
            for(int i = 0; i <= interfaces.length - 1; i++){
                if(i != interfaces.length - 1){
                    interfacesBuf.append(interfaces[i].getName() + ",");
                }else{
                    interfacesBuf.append(interfaces[i].getName());
                }
            }
        }
        String Header = modifier + " class " + classobj.getName() + " extends " + parentName + interfacesBuf.toString() + "{";
        System.out.println(Header + "\n");

        printFields(classobj);
        printMethods(classobj);
        printConstructors(classobj);

        System.out.println("}");
    }

    public static void printFields(Class<?> classobj){
        System.out.println("    //Fileds");
        String modifier = "";
        String type = "";
        String name = "";
        Field [] fields = classobj.getDeclaredFields();
        for(int i = 0; i <= fields.length - 1; i++){
            modifier = Modifier.toString(fields[i].getModifiers());
            type = fields[i].getType().getName();
            name = fields[i].getName();
            System.out.println("    " + modifier + " " + type + " " + name + ";");
        }
        System.out.println();
    }

    public static void printMethods(Class<?> classobj){
        System.out.println("    //Methods");
        String modifier = "";
        String returnType = "";
        String name = "";
        Class [] paraClasses = null;
        StringBuffer paraType = new StringBuffer();
        Method [] methods = classobj.getDeclaredMethods();
        for(int i = 0; i <= methods.length - 1; i++){
            modifier = Modifier.toString(methods[i].getModifiers());
            returnType = methods[i].getReturnType().getName();
            name = methods[i].getName();
            paraClasses = methods[i].getParameterTypes();
            for(int j = 0; j <= paraClasses.length - 1; j++){
                if(j != paraClasses.length - 1){
                    paraType.append(paraClasses[j].getName() + ", ");
                }
                else{
                    paraType.append(paraClasses[j].getName());
                }
            }
            System.out.println("    " + modifier + " " + returnType + " " + name + "(" + paraType.toString() + ")");
        }
        System.out.println();
    }

    public static void printConstructors(Class<?> classobj){
        System.out.println("    //Constructors");
        Constructor [] constructors = classobj.getConstructors();
        String modifier = "";
        String name = "";
        Class [] paraClasses = null;
        StringBuffer paraType = new StringBuffer();
        for(int i = 0; i <= constructors.length - 1; i++){
            modifier = Modifier.toString(constructors[i].getModifiers());
            name = constructors[i].getName();
            paraClasses = constructors[i].getParameterTypes();
            for(int j = 0; j <= paraClasses.length - 1; j++){
                if(j != paraClasses.length - 1){
                    paraType.append(paraClasses[j].getName() + ", ");
                }
                else{
                    paraType.append(paraClasses[j].getName());
                }
            }
            System.out.println("    " + modifier + " " + name + "(" + paraType.toString() + ")");
        }
        System.out.println();
    }
}

六、运行结果

public class ReflectAnalysis.Human extends java.lang.Object{

    //Fileds
    public java.lang.String name;
    private int age;

    //Methods
    public void setAge(int)
    public int getAge(int)

    //Constructors
    public ReflectAnalysis.Human(java.lang.String, int)

}
tterminator
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java常用工具类 Reflect反射工具类、String字符串工具类
08-26
主要为大家详细介绍了java常用工具类，包括Reflect反射工具类、String字符串工具类，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
通过反射技术获得的Field类的解析
m0_47281737的博客
07-21 71
与前面的注释类似，该数组也是空的，这意味着没有直接应用于该字段的注释。提供的 JSON 似乎是使用属性集合来表示 Java 中的字段。，这意味着默认情况下该字段不可访问，并且可能需要额外的权限才能访问其值。：表示声明此字段的类的完全限定名称的字符串。在本例中，该字段在类中声明。：一个布尔值，指示该字段是否是合成的（由编译器生成）。该字段是冗余的，并且提供与该字段相同的信息。：一个布尔值，指示该字段是否表示枚举常量。：一个布尔值，指示该字段是否可访问。：表示字段的通用类型的字符串。，表示该字段不是合成的。
Java Field 详解
z69183787的专栏
09-17 3万+
一.主要方法 getType()： 获取属性声明时类型对象（返回class对象） getGenericType() ： 返回属性声的Type类型 getName() ： 获取属性声明时名字 getAnnotations() ： 获得这个属性上所有的注释 getModifiers() ： 获取属性的修饰 isEnumConstant() ： 判断这个属
Java反射基础(二)--Fileds对象的使用
Useless Programmer 的专栏
10-25 1355
Java反射的官方文档翻译,详细讲述关于Field相关知识.
Reflect() API
wx479的博客
11-05 200
Reflect对象与Proxy对象一样，也是ES6为了操作对象而提供的新API 优点 1.更合理地规划与Object对象相关的API 2.用一个单一的全局对象去存储这些函数，能够保持其他的JavaScript代码的整洁、干净。 3.将一些命令式的操作符如delete、in等使用函数来替代，这样做的目的是为了让代码更好维护，更容易向下兼容，同时也避免出现更多的保留字。 4.修改Object对象的某些函数的返回结果，可以让其变得更合理，使得代码更好维护。 Reflect对象的函数与Proxy对象的函
java reflect_Java反射机制(Reflect)解析
weixin_35654499的博客
02-12 951
一、导读反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用，并在Lisp和面向对象方面取得了成绩。在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来实现对自己行为的描述(self-representati...
Java反射（Reflection）
陈卓410的博客
11-14 331
是被视为的关键，反射机制允许程序在执行期借助于取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为 :。在运行时判断任意一个对象所属的类在运行时构造任意一个类的对象在运行时判断任意一个类所具有的成员变量和方法在运行时获取泛型信息。
java基础-反射(Reflect)
qq_48865614的博客
07-25 414
根加载器没有加载过这个类ClassNotFoundException。先由当前类加载器查看是否加载过这个类如果没有加载过。父类加载器会查看是否加载过这个类继续向上传递。类的加载器加载类的。
【Java基础】反射(reflect)
墩墩分墩
02-28 453
文章目录一.Java类加载器简单了解1.类的加载2.类加载的时机（只加载一次）3.类加载器4.类加载器的组成二.什么是反射机制三.java.lang.Class1.什么是Class对象2.获取Class对象的三种方式?3.Class对象常用方法3.1.获取Class类对应的实体类的相关的Class类的方法3.2.获取构造函数的方法3.3.获取类方法的方法3.4.获取类中属性的方法3.5.获取类中注...
java反射(reflect)
编程学习从入门到放弃
08-28 167
java反射(reflect) 两个重要的认识 编译期间: 程序员在.java文件中写好的代码,然后编译成.class文件,在编程的时候由程序员指定的类与类之间的继承关系 类的方法和属性是在程序员编程时确定好的,jvm拿着这个程序就可以直接运行. 运行期间: 程序员在写程序时,对于类中的方法和属性,并没有指定具体的调用方式和属性值,方法的调用,和属性的赋值是 在程序运行期间,由jvm动态指...
JavaReflect:Java反射测试！
06-02
Java反射的使用 这个小例子简单介绍了Java使用反射的各种方法，帮助大家快速掌握Java反射的基本使用方法。例子程序是用Android Studio编写的,如果你使用Eclipse,新建一个工程,拷贝src下面的几个类过去就可以了....
java-reflect:反射
05-16
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。...
9.3 Java反射reflect
最新发布
04-10
9.3 Java反射reflect
java反射JAVA REFLECT （java 反射）
12-28
JAVA REFLECT （java 反射） 取得类的继承结构 - 类所在的包; |- public Package getPackage() - 类的声明方式; |-取得全类名：public String getName() |-只取类名： public String getSimpleName() - 类所继承...
JAVA 一个或多个空格分割字符串
热门推荐
tterminator的专栏
10-08 5万+
知识补充 String的split方法支持正则表达式； 正则表达式\s表示匹配任何空白字符，+表示匹配一次或多次。 有了以上补充知识，下面的内容就很好理解了。一、待分割字符串待分割字符串为如下：String str = "a b c d e f g"其中，字符串中的的空白分别为：单个空格，多个空格，tab制表符。二、使用一个或多个空格分割字符串正确代码如下：String []
Java执行shell脚本文件完整代码
tterminator的专栏
08-30 3万+
一、背景 最近要下线一台历史遗留的物理机，在整理该机的crontab任务时，发现有不少纯shell脚本形式的定时任务，决定使用Java写一个执行shell脚本文件的通用工具类。 二、实现方式 Java执行shell脚本文件共有两种方式，两种方式的共同点均是创建独立的process执行脚本文件。 方式1：通过Runtime创建process Process process = Runt...
IDEA 安装PlantUML
tterminator的专栏
10-08 2万+
一、IDEA安装PlantUML插件1.ctrl+shift+s打开setting面板，执行如下操作：Plugins-->Install JetBrains plugin...-->搜索plantuml 搜索出PlantUML后，点击安装，重启IDEA，PlantUML插件即可安装成功。二、开始画UML图1.新建UML文件 2.这里以创建时序图为例，输入文件名为UmlSequence
Java获取可用处理器的数目
tterminator的专栏
11-22 1万+
一、背景在多线程并发编程时，在创建线程池时，需要指定线程池的最小线程数和最大线程数，这两个数字的指定一般和可用的处理器数目有关，获取可用处理器的数目的Java代码如下：Runtime.getRuntime().availableProcessors()二、示例代码public static void main(String[] args){ int availProcessors =
Java邮件发送详解（可发送附件）
tterminator的专栏
11-24 1万+
发送前需要引用mail-1.4.5.jar，资源下载参见下载链接。 一、邮件内容实体类package mail;import java.security.GeneralSecurityException; import java.util.Properties;import com.sun.mail.util.MailSSLSocketFactory;public class MailInfo {
仿JAVAP.EXE程序，利用JAVA反射技术分析类的结构；
03-23
可以使用Java反射API中的Class类和Method类来分析类的结构。首先，使用Class.forName()方法获取类的Class对象，然后使用getDeclaredMethods()方法获取类中声明的所有方法，再使用getMethod()方法获取指定方法的Method对象。通过Method对象可以获取方法的名称、参数类型、返回类型等信息。可以使用这些信息来分析类的结构。以下是一个简单的示例代码： ```java import java.lang.reflect.*; public class ReflectDemo { public static void main(String[] args) throws Exception { String className = "java.util.ArrayList"; Class<?> clazz = Class.forName(className); Method[] methods = clazz.getDeclaredMethods(); for (Method method : methods) { System.out.println("Method name: " + method.getName()); System.out.println("Return type: " + method.getReturnType().getName()); Class<?>[] parameterTypes = method.getParameterTypes(); System.out.print("Parameter types: "); for (Class<?> parameterType : parameterTypes) { System.out.print(parameterType.getName() + " "); } System.out.println(); System.out.println("--------------------"); } } } ``` 这个程序可以分析java.util.ArrayList类的结构，输出类中声明的所有方法的名称、返回类型和参数类型。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值