精华内容
下载资源
问答
  • 前面给大家介绍了一下什么是java反射机制,那么下面要给大家介绍的就是java反射机制的原理,那么它的原理究竟是怎样的呢?下面就通过下面来做一下详细的了解吧。首先我们再来介绍一下java反射机制。java反射机制就是...

    前面给大家介绍了一下什么是java反射机制,那么下面要给大家介绍的就是java反射机制的原理,那么它的原理究竟是怎样的呢?下面就通过下面来做一下详细的了解吧。

    首先我们再来介绍一下java反射机制。

    java反射机制就是java程序在运行的时候动态的创建类并调用类的方法以及属性。

    下面就来介绍一下原理。

    一、java反射机制原理

    下面是我们经常可以见到的反射例子:Class

    > clz = Class.forName("java.util.ArrayList");

    ArrayList object = (ArrayList) clz.newInstance();

    Method method = clz.getMethod("add",Object.class);

    method.invoke(list , "sss");

    来分析一下:

    前面的2行实现了类的装载、链接、初始化。

    后面的2行实现了从class对象当中,获取对象,之后执行反射调用。

    这里的话让我们来设想一下,如果,要实现Invoke方法,那么是不是只要实现下面的类就可以了呢?public class Method

    {

    public void invoke(Object obj, Object...args)

    {

    ArrayList list = (ArrayList) obj;

    list.add(args);

    }

    }

    反射的原理之一就是动态的生成类似上面的字节码,加载到jvm当中运行。

    再一起来看看Method对象流程。

    上面的Class对象是在加载类的时候,由jvm构造的。

    jvm为每一个类管理一个独一无二的Class对象,这个Class对象里维护着这个类的所有

    Method、Field、Constructor的cache,这份cache可以被叫做是根对象,每一次,getMethod获取到的Method对象都持有对根对象的引用。

    由于一些重量级的Method的成员变量,大多数都不希望每次在创建Method对象的时候,都要重新进初始化,所以,所有代表同一个方法的Method对象都共享着根对象的MethodAccessor,每一次创建都会调用根对象的copy方法复制一份。Method copy()

    {

    Method res = new Method(clazz, name, parameterTypes, returnType

    , exceptionTypes, modifiers, slot, signature

    , annotations, parameterAnnotations, annotationDefault);

    res.root = this;

    res.methodAccessor = methodAccessor;

    return res;

    }

    调用invoke方法流程

    首先的话,method.invoke方法会获取一个MethodAccessor。

    会先从Method的根对象当中获取MethodAccessor。

    假如是空,那么用reflectionFactory.newMethodAccessor返回DelegatingMethodAccessorImpl实例。

    之后再把MethodAccessor赋值给Method的root对象当中,之后调用DelegatingMethodAccessorImpl当中的invoke方法。

    在调用invoke的次数大于15次之后,MethodAccessor将由java代码生成。

    关于java反射机制原理就给你介绍到这里了,更多java反射机制常见问题,可以继续关注本站来了解。

    推荐阅读:

    展开全文
  • 什么是反射反射,一种计算机处理方式。是程序可以访问、检测和修改它本身状态或行为的一种能力。java反射使得我们可以在程序运行时...类的加载java反射机制是围绕Class类展开的,在深入java反射原理之前,需要对类...

    什么是反射?

    反射,一种计算机处理方式。是程序可以访问、检测和修改它本身状态或行为的一种能力。java反射使得我们可以在程序运行时动态加载一个类,动态获取类的基本信息和定义的方法,构造函数,域等。除了检阅类信息外,还可以动态创建类的实例,执行类实例的方法,获取类实例的域值。反射使java这种静态语言有了动态的特性。

    类的加载

    java反射机制是围绕Class类展开的,在深入java反射原理之前,需要对类加载机制有一个大致的了解。jvm使用ClassLoader将字节码文件(class文件)加载到方法区内存中:

    Class clazz = ClassLoader.getSystemClassLoader().loadClass("com.mypackage.MyClass");

    可见ClassLoader根据类的完全限定名加载类并返回了一个Class对象,而java反射的所有起源都是从这个class类开始的。

    ReflectionData

    为了提高反射的性能,缓存显然是必须的。class类内部有一个useCaches静态变量来标记是否使用缓存,这个值可以通过外部配置项sun.reflect.noCaches进行开关。class类内部提供了一个ReflectionData内部类用来存放反射数据的缓存,并声明了一个reflectionData域,由于稍后进行按需延迟加载并缓存,所以这个域并没有指向一个实例化的ReflectionData对象。

    //标记是否使用缓存,可以通过外部配置项sun.reflect.noCaches进行禁用。

    private static boolean useCaches = true;

    static class ReflectionData {

    volatile Field[] declaredFields;

    volatile Field[] publicFields;

    volatile Method[] declaredMethods;

    volatile Method[] publicMethods;

    volatile Constructor[] declaredConstructors;

    volatile Constructor[] publicConstructors;

    volatile Field[] declaredPublicFields;

    volatile Method[] declaredPublicMethods;

    final int redefinedCount;

    ReflectionData(int redefinedCount) {

    this.redefinedCount = redefinedCount;

    }

    }

    //注意这是个SoftReference,在内存资源紧张的时候可能会被回收。volatile保证多线程环境下的读写的正确性

    private volatile transient SoftReference> reflectionData;

    //J主要用于和ReflectionData中的redefinedCount进行比较,如果两个值不相等,说明ReflectionData缓存的数据已经过期了。

    private volatile transient int classRedefinedCount = 0;

    获取类的构造函数

    在获取一个类的class后,我们可以通过反射获取一个类的所有构造函数,class类内部封装了如下方法用于提取构造函数:

    //publicOnly指示是否只获取public的构造函数,我们常用的getConstructors方法是只返回public的构造函数,而getDeclaredConstructors返回的是所有构造函数,由于java的构造函数不会继承,所以这里不包含父类的构造函数。

    private Constructor[] privateGetDeclaredConstructors(boolean publicOnly) {

    checkInitted(); //主要是读取了sun.reflect.noCaches配置。

    Constructor[] res;

    ReflectionData rd = reflectionData();//这里缓存中读取reflectionData,如果还没有缓存,则创建一个reflectionData并设置到缓存。但是注意这个ReflectionData可能只是个空对象,里面并没有任何数据。

    if (rd != null) {

    res = publicOnly ? rd.publicConstructors : rd.declaredConstructors;

    if (res != null) return res;//检查缓存中是否有数据

    }

    //没有缓存数据可用,从这里开始需要从jvm中去获取数据。

    if (isInterface()) {

    res = new Constructor[0];//接口没有构造函数

    } else {

    res = getDeclaredConstructors0(publicOnly);//native方法,从jvm中获取

    }

    //如果代码执行到了这里,说明需要更新缓存了,将之前从jvm中请求到的数据放置到缓存中。

    if (rd != null) {

    if (publicOnly) {

    rd.publicConstructors = res;

    } else {

    rd.declaredConstructors = res;

    }

    }

    return res;

    }

    上面的代码片段比较简单,主要就是读取配置,检查缓存中是否有有效数据,如果有,直接从缓存中返回,如果没有,调用native的方法从jvm中请求数据,然后设置到缓存。比较重要的是reflectionData()这个调用。这个方法主要是用于延迟创建并缓存ReflectionData对象,注意是对象,里面并没有保存反射数据,这些数据只有在第一次执行相应的反射操作后才会被填充。下面是这个方法的实现代码:

    private ReflectionData reflectionData() {

    SoftReference> reflectionData = this.reflectionData;

    int classRedefinedCount = this.classRedefinedCount;

    ReflectionData rd;

    //检查缓存是否有效,如果有效,从缓存中直接返回reflectionData。

    if (useCaches &&

    reflectionData != null &&

    (rd = reflectionData.get()) != null &&

    rd.redefinedCount == classRedefinedCount) {

    return rd;

    }

    //无法使用到缓存,创建新的reflectionData

    return newReflectionData(reflectionData, classRedefinedCount);

    }

    下面看一下newReflectionData()的实现:

    private ReflectionData newReflectionData(SoftReference> oldReflectionData,int classRedefinedCount) {

    if (!useCaches) return null;

    //这里使用while-cas模式更新reflectionData,主要是考虑多线程并发更新的问题,可能有另外一个线程已经更新了reflectionData,并且设置了有效的缓存数据,如果这里再次更新就把缓存数据覆盖了。

    while (true) {

    ReflectionData rd = new ReflectionData<>(classRedefinedCount);

    if (Atomic.casReflectionData(this, oldReflectionData, new SoftReference<>(rd))) {

    return rd;//cas成功,那么我们swap的这个新对象是有效的。

    }

    //重新读取oldReflectionData,为下次重试cas做准备。

    oldReflectionData = this.reflectionData;

    classRedefinedCount = this.classRedefinedCount;

    //先判断这个oldReflectionData是否有效。如果是无效的数据,需要去重试cas一个新的ReflectionData了。

    if (oldReflectionData != null &&

    (rd = oldReflectionData.get()) != null &&

    rd.redefinedCount == classRedefinedCount) {

    return rd;//reflectionData中已经是有效的缓存数据了,直接返回这个reflectionData

    }

    }

    }

    上面的几个代码片段是反射获取一个类的构造函数的主要方法调用。主要流程就是先从class内部的reflectionData缓存中读取数据,如果没有缓存数据,那么就从jvm中去请求数据,然后设置到缓存中,供下次使用。

    执行构造函数

    在通过反射获取到一个类的构造函数我们,一般我们会试图通过构造函数去实例化声明这个构造函数的类,如下:

    MyClass myClass = (MyClass) constructor.newInstance();

    下面来看看这个newInstance()到底发生了什么:

    public T newInstance(Object... initargs)

    throws InstantiationException, IllegalAccessException,

    IllegalArgumentException, InvocationTargetException {

    //首先判断语言级别的访问检查是否被覆盖了(通过setAccess(true)方法可以将private的成员变成public),如果没有被覆盖,需要进行访问权限检查。

    if (!override) {

    if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {

    Class> caller = Reflection.getCallerClass();

    checkAccess(caller, clazz, null, modifiers);

    }

    }

    //枚举无法通过反射创建实例

    if ((clazz.getModifiers() & Modifier.ENUM) != 0)

    throw new IllegalArgumentException("Cannot reflectively create enum objects");

    //创建ConstructorAccessor对象,并进行缓存

    ConstructorAccessor ca = constructorAccessor;

    if (ca == null) {

    ca = acquireConstructorAccessor();

    }

    //通过ConstructorAccessor来执行newInstance

    return (T) ca.newInstance(initargs);

    }

    上面代码主要就是做权限检查,如果权限通过,则通过执行acquireConstructorAccessor()获取一个ConstructorAccessor来真正执行newInstance,acquireConstructorAccessor()这个方法实现比较简单,真正工作的是ReflectionFactory.newConstructorAccessor(),这个方法的主要工作就是为一个Constructor动态生成针对ConstructorAccessor接口的实现ConstructorAccessorImpl,下面来看一下这个方法实现:

    public ConstructorAccessor newConstructorAccessor(Constructor c) {

    checkInitted();

    Class declaringClass = c.getDeclaringClass();

    //如果声明这个构造函数的类部是抽象类,则返回一个InstantiationExceptionConstructorAccessorImpl,这其实也是个ConstructorAccessor,只是它对newInstace的实现是直接抛出一个InstantiationException异常

    if (Modifier.isAbstract(declaringClass.getModifiers())) {

    return new InstantiationExceptionConstructorAccessorImpl(null);

    }

    //如果是Class,同上

    if (declaringClass == Class.class) {

    return new InstantiationExceptionConstructorAccessorImpl

    ("Can not instantiate java.lang.Class");

    }

    //如果是ConstructorAccessorImpl子类,这里会造成无限循环,所以直接通过native方式实例化这个类

    if (Reflection.isSubclassOf(declaringClass,

    ConstructorAccessorImpl.class)) {

    return new BootstrapConstructorAccessorImpl(c);

    }

    //判断是否启用了Inflation机制,默认是启用了。

    //如果没有启用Inflation机制,那么通过asm操作字节码的方式来生成一个ConstructorAccessorImpl类。

    //如果启用了,那么在执行inflationThreshold(默认15次)次数之前,是通过navite调用来执行newInstance,超过这个次数之后,才会通过asm来生成类。

    //Inflation机制主要是在执行时间和启动时间上做一个平衡,native方式执行慢但是第一次执行不耗费任何时间,asm生成代码的方式执行快(20倍),但是第一次生成需要耗费大量的时间。

    //可以通过sun.reflect.noInflation和sun.reflect.inflationThreshold配置型来进行动态配置

    if (noInflation) {

    return new MethodAccessorGenerator().

    generateConstructor(c.getDeclaringClass(),

    c.getParameterTypes(),

    c.getExceptionTypes(),

    c.getModifiers());

    } else {

    NativeConstructorAccessorImpl acc =

    new NativeConstructorAccessorImpl(c);

    DelegatingConstructorAccessorImpl res =

    new DelegatingConstructorAccessorImpl(acc);

    acc.setParent(res);

    return res;

    }

    }

    由上面代码可见,在生成ConstructorAccessorImpl的操作上,一共提供多种版本的实现:直接抛出异常的实现,native执行的实现,asm生成代码的实现。native的实现比较简单,asm 版本的主要就是字节码操作了,比较复杂,暂时不做深入了。

    展开全文
  • JAVA反射原理

    2019-03-01 16:29:39
    JAVA反射原理1 JAVA反射原理2 JAVA反射原理3

    What,s 反射

    反射是个啥?
    为啥要反射?
    反射怎么弄?

    要弄懂反射,首先需要回答关于反射的这三大问题。
    这篇博客的主要目的就是深入浅出地来回答这三个问题。

    RTTI

    “卧槽,这是啥,为啥带我到这里,我要知道啥是反射,这四个让人看不懂的字母是个啥。”
    骚年,别着急,一步一步来学习,要搞懂反射,先要认识反射他爸(干爸吧),RTTI(Runtime Type Information,运行时类型信息)

    并不是所有的Class都能在编译时明确,因此在某些情况下需要在运行时再发现和确定类型信息(比如:基于构建编程,),这就是RTTI(Runtime Type Information,运行时类型信息)。

    在java中,有两种RTTI的方式,一种是传统的,即假设在编译时已经知道了所有的类型;还有一种,是利用反射机制,在运行时再尝试确定类型信息。

    本文主要讲反射方式实现的RTTI,建议在阅读本文之前,先了解类的加载机制(参考我的博客:JAVA类加载详解)。

    传统的RTTI

    严格的说,反射也是一种形式的RTTI,不过,一般的文档资料中把RTTI和反射分开,因为一般的,大家认为RTTI指的是传统的RTTI,通过继承和多态来实现,在运行时通过调用超类的方法来实现具体的功能(超类会自动实例化为子类,或使用instance of)。

    传统的RTTI有3种实现方式:

    • 向上转型或向下转型(upcasting and downcasting),在java中,向下转型(父类转成子类)需要强制类型转换
    • Class对象(用了Class对象,不代表就是反射,如果只是用Class对象cast成指定的类,那就还是传统的RTTI)
    • instanceof或isInstance()

    传统的RTTI与反射最主要的区别,在于RTTI在编译期需要.class文件,而反射不需要。传统的RTTI使用转型或Instance形式实现,但都需要指定要转型的类型。

    public void rtti(Object obj){
        Toy toy = Toy(obj);
        // Toy toy = Class.forName("myblog.rtti.Toy")
        // obj instanceof Toy
    }
    

    obj虽然是被转型了,但在编译期,就需要知道要转成的类型Toy,也就是需要Toy的.class文件。

    相对的,反射完全在运行时在通过Class类来确定类型,不需要提前加载Toy的.class文件。

    反射

    那到底什么是反射(Reflection)呢?反射有时候也被称为内省(Introspection),事实上,反射,就是一种内省的方式,**Java不允许在运行时改变程序结构或类型变量的结构,但它允许在运行时去探知、加载、调用在编译期完全未知的class,可以在运行时加载该class,生成实例对象(instance object),调用method,或对field赋值。

    关于Java的反射API,没必要去记忆,可以在任何JDK API中查询即可:

    Class类:http://www.ostools.net/uploads/apidocs/jdk-zh/java/lang/Class.html

    reflect包:http://www.ostools.net/uploads/apidocs/jdk-zh/java/lang/reflect/package-summary.html

    反射的缺点

    这世界上没有什么东西是完美的,口中完美的东西反而死的越快。就像…,能举出来的例子就像省略号一样多。

    • 复杂(本来JAVA敲得好好的,你突然出来个反射)
    • 效率低(18弯的山路肯定要比直直的大马路效率要低)

    反射有什么用

    灵活,没错,反射的优点就只有这一个,但却是最致命的那一个。它让JAVA变成了一个风骚的绅士,颇具魅力。让其在各大语言的战斗中,深得程序员的深爱。
    如果JAVA没有反射,就像哈士奇没有了傻二,就像猫咪没有了可爱,就像我没有了帅气。真的太严重了。

    没有了反射首先:
    1.所有简单好用的框架和骚代码都消失了

    没错,就这一点就足够致命了,所以真的难以想象失去了反射的JAVA还能走多远,就像真的难以想象失去帅气的我还有什么用。(写到这里我有点被自己感动的想哭)

    反射的底层原理

    反射的底层,这里主要讲解Method的获取与执行

    Method获取

    调用Class类的getDeclaredMethod可以获取指定方法名和参数的方法对象Method。

    getDeclaredMethod
    在这里插入图片描述
    这里,我们看到privateGetDeclaredMethods和searchMethods两个看起来陌生又重要的方法,privateGetDeclaredMethods方法从缓存或JVM中获取该Class中申明的方法列表,searchMethods方法将从返回的方法列表里找到一个匹配名称和参数的方法对象。

    searchMethods
    在这里插入图片描述

    如果找到一个匹配的Method,则重新copy一份返回,即Method.copy()方法。
    所次每次调用getDeclaredMethod方法返回的Method对象其实都是一个新的对象,且新对象的root属性都指向原来的Method对象,如果需要频繁调用,最好把Method对象缓存起来。

    privateGetDeclaredMethods
    从缓存或JVM中获取该Class中申明的方法列表,实现如下:
    在这里插入图片描述

    其中reflectionData()方法实现如下:
    在这里插入图片描述

    这里有个比较重要的数据结构ReflectionData,用来缓存从JVM中读取类的如下属性数据:
    在这里插入图片描述

    从reflectionData()方法实现可以看出:reflectionData对象是SoftReference类型的,说明在内存紧张时可能会被回收,不过也可以通过-XX:SoftRefLRUPolicyMSPerMB参数控制回收的时机,只要发生GC就会将其回收,如果reflectionData被回收之后,又执行了反射方法,那只能通过newReflectionData方法重新创建一个这样的对象了,newReflectionData方法实现如下:
    在这里插入图片描述

    通过unsafe.compareAndSwapObject方法重新设置reflectionData字段;

    在privateGetDeclaredMethods方法中,如果通过reflectionData()获得的ReflectionData对象不为空,则尝试从ReflectionData对象中获取declaredMethods属性,如果是第一次,或则被GC回收之后,重新初始化后的类属性为空,则需要重新到JVM中获取一次,并赋值给ReflectionData,下次调用就可以使用缓存数据了。

    Method调用

    获取到指定的方法对象Method之后,就可以调用它的invoke方法了,invoke实现如下:
    在这里插入图片描述

    应该注意到:这里的MethodAccessor对象是invoke方法实现的关键,一开始methodAccessor为空,需要调用acquireMethodAccessor生成一个新的MethodAccessor对象,MethodAccessor本身就是一个接口,实现如下:
    在这里插入图片描述
    在acquireMethodAccessor方法中,会通过ReflectionFactory类的newMethodAccessor创建一个实现了MethodAccessor接口的对象,实现如下:
    在这里插入图片描述

    在ReflectionFactory类中,有2个重要的字段:noInflation(默认false)和inflationThreshold(默认15),在checkInitted方法中可以通过-Dsun.reflect.inflationThreshold=xxx和-Dsun.reflect.noInflation=true对这两个字段重新设置,而且只会设置一次;

    如果noInflation为false,方法newMethodAccessor都会返回DelegatingMethodAccessorImpl对象,DelegatingMethodAccessorImpl的类实现
    在这里插入图片描述

    其实,DelegatingMethodAccessorImpl对象就是一个代理对象,负责调用被代理对象delegate的invoke方法,其中delegate参数目前是NativeMethodAccessorImpl对象,所以最终Method的invoke方法调用的是NativeMethodAccessorImpl对象invoke方法,实现如下:

    在这里插入图片描述
    这里用到了ReflectionFactory类中的inflationThreshold,当delegate调用了15次invoke方法之后,如果继续调用就通过MethodAccessorGenerator类的generateMethod方法生成MethodAccessorImpl对象,并设置为delegate对象,这样下次执行Method.invoke时,就调用新建的MethodAccessor对象的invoke()方法了。

    这里需要注意的是:
    generateMethod方法在生成MethodAccessorImpl对象时,会在内存中生成对应的字节码,并调用ClassDefiner.defineClass创建对应的class对象,实现如下:
    在这里插入图片描述

    在ClassDefiner.defineClass方法实现中,每被调用一次都会生成一个DelegatingClassLoader类加载器对象
    在这里插入图片描述

    这里每次都生成新的类加载器,是为了性能考虑,在某些情况下可以卸载这些生成的类,因为类的卸载是只有在类加载器可以被回收的情况下才会被回收的,如果用了原来的类加载器,那可能导致这些新创建的类一直无法被卸载,从其设计来看本身就不希望这些类一直存在内存里的,在需要的时候有就行了。

    参考链接:
    JAVA反射原理0
    JAVA反射原理1
    JAVA反射原理2
    JAVA反射原理3

    展开全文
  • 一、什么是JAVA反射1、在运行状态中,对于任意一个类,都能够知道这个类的属性和方法。2、对于任意一个对象,都能够调用它的...三、反射原理JAVA语言编译之后会生成一个.class文件,反射就是通过字节码文件找...

    一、什么是JAVA的反射

    1、在运行状态中,对于任意一个类,都能够知道这个类的属性和方法。

    2、对于任意一个对象,都能够调用它的任何方法和属性。

    这种动态获取信息以及动态调用对象的方法的功能称为JAVA的反射。

    二、反射的作用

    在JAVA中,只有给定类的名字,就可以通过反射机制来获取类的所有信息,可以动态的创建对象和编译。

    三、反射的原理

    JAVA语言编译之后会生成一个.class文件,反射就是通过字节码文件找到某一个类、类中的方法以及属性等。

    反射的实现主要借助以下四个类:

    Class:类的对象

    Constructor:类的构造方法

    Field:类中的属性对象

    Method:类中的方法对象

    1、获取类对象:

    通过类名获取Class对象,Class c = Class.forName("类的完全路径");

    通过Class对象获取具体的类对象:Object o = (Object) c.newInstance();

    2、获取类中的构造方法:

    be62ba9e0c7515680626a89719bd7867.png

    ad8e311b2cf266f5efc92282f132d380.png

    3、获取类中的属性:

    f24a72eb61788b7ff175e3446d7a036b.png

    2e9d38094f309672e73ce26c7672c7a6.png

    4、获取类中的方法:

    38eb32e5511d9e4a62a2a46f40d89ed9.png

    6b12a31e227f389489f3abb3dd75cc64.png

    四、代码演示

    1 packagereflection;2

    3 importjava.io.Serializable;4

    5 public class DemoTest implementsSerializable6 {7 /**

    8 * 注释内容9 */

    10 private static final long serialVersionUID = 1L;11

    12 publicString name;13 public intage;14

    15 publicDemoTest()16 {17 }18

    19 public DemoTest(String name, intage)20 {21 this.name =name;22 this.age =age;23 }24

    25 public voidsayHello(String param)26 {27 System.out.println("hello " +param);28 }29

    30 publicString getName()31 {32 returnname;33 }34

    35 public voidsetName(String name)36 {37 this.name =name;38 }39

    40 public intgetAge()41 {42 returnage;43 }44

    45 public void setAge(intage)46 {47 this.age =age;48 }49 }

    测试类:

    1 packagereflection;2

    3 importjava.lang.reflect.Constructor;4 importjava.lang.reflect.Field;5 importjava.lang.reflect.Method;6

    7 public classTest8 {9 public static void main(String[] args) throwsException10 {11 //获取类DemoTest的Class对象

    12 Class> c = Class.forName("reflection.DemoTest");13 //打印该Class对象对表示的类的名称

    14 System.out.println(c.getName());15 //获取该类的实例

    16 System.out.println(c.newInstance());17

    18 System.out.println("-------------------------------------------");19 //获取该类实现的接口

    20 Class>[] interfaces =c.getInterfaces();21 System.out.println(interfaces[0].getName());22

    23 System.out.println("-------------------------------------------");24 //获取有参构造函数

    25 Constructor> con = c.getConstructor(String.class,int.class);26 DemoTest dt = (DemoTest)con.newInstance("xiaoming",12);27 System.out.println(dt.getAge());28

    29 System.out.println("-------------------------------------------");30 //获取类的成员变量

    31 Field f2 = c.getField("age");32 System.out.println(f2);33 //获取指定对象上该字段表示的值

    34 System.out.println(f2.get(dt));35

    36 System.out.println("-------------------------------------------");37 //获取指定的方法

    38 Method m = c.getMethod("sayHello", String.class);39 //反射调用方法,非常重要

    40 m.invoke(dt, "hangzhou");41 }42 }

    测试结果:

    reflection.DemoTest

    reflection.DemoTest@15db9742-------------------------------------------java.io.Serializable-------------------------------------------

    12

    -------------------------------------------

    public intreflection.DemoTest.age12

    -------------------------------------------hello hangzhou

    展开全文
  • java反射原理

    2016-03-21 09:30:11
    java反射原理
  • 1.什么是反射反射原理java反射原理:java类的执行需要经历以下过程,编译:.java文件编译后生成.class字节码文件加载:类加载器负责根据一个类的全限定名来读取此类的二进制字节流到JVM内部,并存储在运行时内存区...
  • 一、反射的概述与初衷1、反射的概述Java反射机制是在运行状态中,对于任意一个类都能知道它的所有属性和方法;对于任意一个对象都能调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能...
  • 本文实例讲述了Java反射技术原理与用法。分享给大家供大家参考,具体如下:本文内容:产生反射技术的需求反射技术的使用一个小示例首发日期:2018-05-10产生反射技术的需求:项目完成以后,发现需要增加功能,并且...
  • Java面试宝典面试必问的试题解析Java的Class与反射机制原理程序猿出品面试辅导入职阶梯 顺利入职大厂,赢得百万年薪,是每个入职It业的程序员所渴望的,但是僧多粥少,能够实现愿望的毕竟是少数。如何在激烈的竞争中...
  • java反射机制的实现原理反射机制:所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。下面具体介绍一下java反射机制。这里你将颠覆原来对java的...
  • Java反射原理

    2015-07-26 17:57:25
    上传文件关于Java反射原理 本人整理经验
  • java反射机制原理1

    2009-05-14 10:46:01
    java反射机制原理1java反射机制原理1java反射机制原理1java反射机制原理1
  • 对于java反射机制你了解多少呢?很多人表示对于它的原理都不是很清楚,下面就一起来详细的进行一下了解吧!首先我们要清楚概念,一切皆对象,类也是对象;之后要晓得类当中的东西,modifier constructor field method;...
  • java反射原理详解

    2017-08-10 11:32:26
    java反射原理详解
  • 反射Java中的一个重要的特性,使用反射可以在运行时动态生成对象、获取...本篇文章针对Java反射基本原理做一些探究,以期对Java反射机制有较为清晰的认识。由于网上的源码级的博客很多,本篇文章主要总结思...
  • 最近复习反射想了解背后的原理,才发现这趟水远比我想象中的深,也才发现反射的伟大之处。Reflect实际上是个Class对象操控大师,后文会分析。1.反射的介绍Java在运行中(RunTime):获取任意类的方法和属性,并实例化...
  • java反射机制原理

    2007-11-15 08:24:55
    java反射机制原理
  • java反射机制原理

    2020-08-26 00:21:00
    java反射机制原理 Java反射机制的原理和用途 为什么要反射
  • 反射技术Java原理

    2012-12-25 20:54:34
    反射技术Java原理   Java的反射技术非常重要!我认识的很多朋友总是忽略这点。平时项目中没有用过所以没把他作为重点,其实这是错误 的。其实很多人每天都在用反射技术只是不知道而已。比如我们常用的框架 ...
  • java 反射原理

    2018-08-03 10:58:01
    一、什么是JAVA反射 1、在运行状态中,对于任意一个类,都能够知道这个类的属性和方法。 2、对于任意一个对象,都能够调用它的任何方法和属性。...三、反射原理 JAVA语言编译之后会生成一个.class文...
  • Java反射机制原理剖析

    2017-11-22 11:17:23
    java反射原理
  • java反射原理,作用

    万次阅读 多人点赞 2018-10-17 14:31:44
    Java反射原理:java类的执行需要经历以下过程, 编译:.java文件编译后生成.class字节码文件 加载:类加载器负责根据一个类的全限定名来读取此类的二进制字节流到JVM内部,并存储在运行时内存区的方法区,然后将其...
  • 一、预先需要掌握的知识(java虚拟机)java虚拟机的方法区:java虚拟机有一个运行时数据区,这个数据区又被分为方法区,堆区和栈区,我们这里需要了解的主要是方法区。方法区的主要作用是存储被装载的类的类型信息,当...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,117
精华内容 2,046
关键字:

反射java原理

java 订阅