java的反射机制浅谈

一、java的反射机制浅谈

 

最近研究java研究得很给力,主要以看博文为学习方式。以下是我对java的反射机制所产生的一些感悟,希望各位童鞋看到失误之处不吝指出。受到各位指教之处,如若让小生好好感动,说不定会请各位吃饭哦!

 

1.何谓反射机制

 

根据网文,java中的反射机制可以如此定义:

JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

 

2.反射机制如何实现

 

谈到反射机制,最诱人的莫过于“动态”二字了。接触过C语言的童鞋们都知道,C语言中也有个和“动态”搭上边的函数:malloc()函数。其实这里的两个动态是一个意思,都指的是非编译时处理,抑或运行时处理。这种机制,可以让程序的弹性增加不少,因为借由此机制,客户可以在程序运行时改变一些他关心的性质:分配内存(当然他可能 完全不知道这么做了),调用某个类(当然他还是被蒙在鼓里)等。

下面我们就聊聊java中动态机制是如何实现的。

 

上一篇文章中提到了java的类的加载问题,但没有更深入地解释其运行机制,在这里就先谈谈这个问题。

 

首先不得不提到的是java.lang.Class这个类。

有这么一段话:

Java程序在运行时,Java运行时系统一直对所有的对象进行所谓的运行时类型标识。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行,用来保存这些类型信息的类是Class类。

 

也就是说,ClassLoader找到了需要调用的类时(java为了调控内存的调用消耗,类的加载都在需要时再进行,很抠但是很有效),就会加载它,然后根据.class文件内记载的类信息来产生一个与该类相联系的独一无二的Class对象。该Class对象记载了该类的字段,方法等等信息。以后jvm要产生该类的实例,就是根据内存中存在的该Class类所记载的信息(Class对象应该和我所了解的其他类一样会在堆内存内产生、消亡)来进行。

 

而java中的Class类对象是可以人工自然性的(也就是说开放的)得到的(虽然你无法像其他类一样运用构造器来得到它的实例,因为

Class对象都是jvm产生的。不过话说回来,客户产生的话也是无意义的),而且,更伟大的是,基于这个基础,java实现了反射机制。

 

获取Class对象有三种方式:

 

1.通过Object类的getClass()方法。例如:

Class c1 = new String("").getClass();

2.通过Class类的静态方法——forName()来实现:

Class c2 = Class.forName("MyObject");

3.如果T是一个已定义的类型的话,在java中,它的.class文件名:T.class就代表了与其匹配的Class对象,例如:

Class c3 = Manager.class;

Class c4 = int.class;

Class c5 = Double[].class;


这里需要解释一下3:请记住一句话,java中,一切皆对象。也就是说,基本类型int float 等也会在jvm的内存池像其他类型一样中生成

一个Class对象。而数组等组合型数据类型也是会生成一个Class对象的,而且更令人惊讶的是,java中数组的本来面目其实就是某个类,惊讶

中的惊讶是,含有相同元素的相同维数的数组还会共同享用同一个Class对象!其实根据我的臆想,数组的length性质应该就保存在这个Class

对象里面。

 

Class类中存在以下几个重要的方法:

 

1.getName()

一个Class对象描述了一个特定类的特定属性,而这个方法就是返回String形式的该类的简要描述。由于历史原因,对数组的Class对象

调用该方法会产生奇怪的结果。


2.newInstance()

该方法可以根据某个Class对象产生其对应类的实例。需要强调的是,它调用的是此类的默认构造方法。例如:

MyObject x = new MyObject();

MyObject y = x.getClass().newInstance();


3.getClassLoader()

返回该Class对象对应的类的类加载器。

 

4.getComponentType()

该方法针对数组对象的Class对象,可以得到该数组的组成元素所对应对象的Class对象。例如:

int[] ints = new int[]{1,2,3};

Class class1 = ints.getClass();

Class class2 = class1.getComponentType();

而这里得到的class2对象所对应的就应该是int这个基本类型的Class对象。

 

5.getSuperClass()

返回某子类所对应的直接父类所对应的Class对象。

 

6.isArray()

判定此Class对象所对应的是否是一个数组对象。

 

好啦,现在对Class这个类应该有了一个大致的了解,下面就给出一个反射机制的典型例子供各位分析:

[java]  view plain copy print ?
  1. import java.lang.reflect.Array;     
  2. import java.lang.reflect.Constructor;     
  3. import java.lang.reflect.Field;     
  4. import java.lang.reflect.Method;     
  5.     
  6.     
  7. /**   
  8.  * Java Reflection Cookbook   
  9.  *   
  10.  * @author Michael Lee   
  11.  * @since 2006-8-23   
  12.  * @version 0.1a   
  13.  */    
  14.     
  15. public class Reflection {     
  16.     /**   
  17.      * 得到某个对象的公共属性   
  18.      *   
  19.      * @param owner, fieldName   
  20.      * @return 该属性对象   
  21.      * @throws Exception   
  22.      *   
  23.      */    
  24.     public Object getProperty(Object owner, String fieldName) throws Exception {     
  25.         Class ownerClass = owner.getClass();     
  26.     
  27.         Field field = ownerClass.getField(fieldName);     
  28.     
  29.         Object property = field.get(owner);     
  30.     
  31.         return property;     
  32.     }     
  33.     
  34.     /**   
  35.      * 得到某类的静态公共属性   
  36.      *   
  37.      * @param className   类名   
  38.      * @param fieldName   属性名   
  39.      * @return 该属性对象   
  40.      * @throws Exception   
  41.      */    
  42.     public Object getStaticProperty(String className, String fieldName)     
  43.             throws Exception {     
  44.         Class ownerClass = Class.forName(className);     
  45.     
  46.         Field field = ownerClass.getField(fieldName);     
  47.     
  48.         Object property = field.get(ownerClass);     
  49.     
  50.         return property;     
  51.     }     
  52.     
  53.     
  54.     /**   
  55.      * 执行某对象方法   
  56.      *   
  57.      * @param owner   
  58.      *            对象   
  59.      * @param methodName   
  60.      *            方法名   
  61.      * @param args   
  62.      *            参数   
  63.      * @return 方法返回值   
  64.      * @throws Exception   
  65.      */    
  66.     public Object invokeMethod(Object owner, String methodName, Object[] args)     
  67.             throws Exception {     
  68.     
  69.         Class ownerClass = owner.getClass();     
  70.     
  71.         Class[] argsClass = new Class[args.length];     
  72.     
  73.         for (int i = 0, j = args.length; i < j; i++) {     
  74.             argsClass[i] = args[i].getClass();     
  75.         }     
  76.     
  77.         Method method = ownerClass.getMethod(methodName, argsClass);     
  78.     
  79.         return method.invoke(owner, args);     
  80.     }     
  81.     
  82.     
  83.       /**   
  84.      * 执行某类的静态方法   
  85.      *   
  86.      * @param className   
  87.      *            类名   
  88.      * @param methodName   
  89.      *            方法名   
  90.      * @param args   
  91.      *            参数数组   
  92.      * @return 执行方法返回的结果   
  93.      * @throws Exception   
  94.      */    
  95.     public Object invokeStaticMethod(String className, String methodName,     
  96.             Object[] args) throws Exception {     
  97.         Class ownerClass = Class.forName(className);     
  98.     
  99.         Class[] argsClass = new Class[args.length];     
  100.     
  101.         for (int i = 0, j = args.length; i < j; i++) {     
  102.             argsClass[i] = args[i].getClass();     
  103.         }     
  104.     
  105.         Method method = ownerClass.getMethod(methodName, argsClass);     
  106.     
  107.         return method.invoke(null, args);     
  108.     }     
  109.     
  110.     
  111.     
  112.     /**   
  113.      * 新建实例   
  114.      *   
  115.      * @param className   
  116.      *            类名   
  117.      * @param args   
  118.      *            构造函数的参数   
  119.      * @return 新建的实例   
  120.      * @throws Exception   
  121.      */    
  122.     public Object newInstance(String className, Object[] args) throws Exception {     
  123.         Class newoneClass = Class.forName(className);     
  124.     
  125.         Class[] argsClass = new Class[args.length];     
  126.     
  127.         for (int i = 0, j = args.length; i < j; i++) {     
  128.             argsClass[i] = args[i].getClass();     
  129.         }     
  130.     
  131.         Constructor cons = newoneClass.getConstructor(argsClass);     
  132.     
  133.         return cons.newInstance(args);     
  134.     
  135.     }     
  136.     
  137.     
  138.          
  139.     /**   
  140.      * 是不是某个类的实例   
  141.      * @param obj 实例   
  142.      * @param cls 类   
  143.      * @return 如果 obj 是此类的实例,则返回 true   
  144.      */    
  145.     public boolean isInstance(Object obj, Class cls) {     
  146.         return cls.isInstance(obj);     
  147.     }     
  148.          
  149.     /**   
  150.      * 得到数组中的某个元素   
  151.      * @param array 数组   
  152.      * @param index 索引   
  153.      * @return 返回指定数组对象中索引组件的值   
  154.      */    
  155.     public Object getByArray(Object array, int index) {     
  156.         return Array.get(array,index);     
  157.     }     
  158. }    

例子的解释就免了,因为读代码加上自己理解是最好的程序员学习方式。另外,此代码来源为互联网。

 

好啦,就到这里了。当你知道了java的反射机制后,以后当你接触到java的动态代理时就不会像我一样茫然了。好啦,谢谢围观!

你可能感兴趣的:(java的反射机制浅谈)