Java 类反射机制分析
一、反射的概念及在Java中的类反射
反射主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。在计算机科学领域,反射是一类应用,它们能够自描述和自控制。这类应用通过某种机制来实现对自己行为的描述和检测,并能根据自身行为的状态和结果,调整或修改应用所描述行为的状态和相关的语义。
在Java中的反射机制,被称为Reflection。(大家看到这个单词,第一个想法应该就是去开发文档中搜一下了。)它允许运行中的Java程序对自身进行检查,并能直接操作程序的内部属性或方法。Reflection机制允许程序在正在执行的过程中,利用Reflection APIs取得任何已知名称的类的内部信息,包括:package、 type parameters、 superclass、 implemented interfaces、 inner classes、 outer classes、 fields、 constructors、 methods、 modifiers等,并可以在执行的过程中,动态生成Instances、变更fields内容或唤起methods。
好,了解这些,那我们就知道了,我们可以利用反射机制在Java程序中,动态的去调用一些protected甚至是private的方法或类,这样可以很大程度上满足我们的一些比较特殊需求。你当然会问,反射机制在Android平台下有何用处呢?
我们在进行Android程序的开发时,为了方便调试程序,并快速定位程序的错误点,会从网上下载到对应版本的Android SDK的源码(这里给大家提供一个2.3.3版本的下载链接)。你会发现很多类或方法中经常加上了“@hide”注释标记,它的作用是使这个方法或类在生成SDK时不可见,那么我们的程序可能无法编译通过,而且在最终发布的时候,就可能存在一些问题。
那么,对于这个问题,第一种方法就是自己去掉Android源码中的"@hide"标记,然后重新编译生成一个SDK。另一种方法就是使用Java反射机制了,可以利用这种反射机制访问存在访问权限的方法或修改其域。
废话半天,该入正题了,在进入正题之前,先给上一个反射测试类的代码,该代码中定义了我们需要进行反射的类,该类并没有实际的用途,仅供做为测试类。提示:本文提供的代码,并不是Android平台下的代码,而是一个普通的Java程序,仅仅是对Java反射机制的Demo程序,所以大家不要放在Android下编译啊,否则出现问题,别追究我的责任啦!
package crazypebble.reflectiontest; import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.Serializable; publicclass ReflectionTest extends Object implements ActionListener,Serializable{ // 成员变量
privateint bInt;
public Integer bInteger =new Integer(4);
public String strB ="crazypebble";
private String strA; // 构造函数
public ReflectionTest() {
} protected ReflectionTest(int id, String name) {
} // 成员方法
publicint abc(int id, String name) {
System.out.println("crazypebble ---> "+ id +"-"+ name);
return0;
} protectedstaticvoid edf() {
} @Override
publicvoid actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
}
} package crazypebble.reflectiontest; import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.Serializable; public class ReflectionTest extends Object implements ActionListener,Serializable{ // 成员变量
private int bInt;
public Integer bInteger = new Integer(4);
public String strB = "crazypebble";
private String strA; // 构造函数
public ReflectionTest() { } protected ReflectionTest(int id, String name) { } // 成员方法
public int abc(int id, String name) {
System.out.println("crazypebble ---> " + id + "-" + name);
return 0;
} protected static void edf() { } @Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub } }
二、反射机制中需要使用到的类
我把需要使用的类列在下表中,其中对我们特别有用的类,通过着重标记显示出来,并将在后面的使用中逐步解释:
三、Class类
首先向大家说明一点,Class本身就是一个类,Class是该类的名称。看以下下面这个类的定义:
public class MyButton extends Button {...}
注意到上面的class的首字母是小写,它表示的是一种类类型,但是我们的Class是一个类,相当于上面定义的MyButton类。所以,千万不要把这里的Class做为一个类类型来理解。明白这一点,我们继续。
Class类是整个Java反射机制的源头,Class类本身表示Java对象的类型,我们可通过一个Object对象的getClass()方法取得一个对象的类型,此函数返回的就是一个Class类。获取Class对象的方法有很多种:
在平时的使用,要注意对这几种方法的灵活运用,尤其是对Class.forName()方法的使用。因为在很多开发中,会直接通过类的名称取得Class类的对象。
四、获取类的相关信息
1、获取构造方法
Class类提供了四个public方法,用于获取某个类的构造方法。
Constructor getConstructor(Class[] params) 根据构造函数的参数,返回一个具体的具有public属性的构造函数
Constructor getConstructors() 返回所有具有public属性的构造函数数组
Constructor getDeclaredConstructor(Class[] params) 根据构造函数的参数,返回一个具体的构造函数(不分public和非public属性)
Constructor getDeclaredConstructors() 返回该类中所有的构造函数数组(不分public和非public属性)
由于Java语言是一种面向对象的语言,具有多态的性质,那么我们可以通过构造方法的参数列表的不同,来调用不同的构造方法去创建类的实例。同样,获取不同的构造方法的信息,也需要提供与之对应的参数类型信息;因此,就产生了以上四种不同的获取构造方法的方式。
/**
* 获取反射类中的构造方法
* 输出打印格式:"Modifier修饰域 构造方法名(参数类型列表)"
*/
publicstaticvoid get_Reflection_Constructors(ReflectionTest r) { Class temp = r.getClass();
String className = temp.getName(); // 获取指定类的类名 try {
Constructor[] theConstructors = temp.getDeclaredConstructors(); // 获取指定类的公有构造方法 for (int i =0; i < theConstructors.length; i++) {
int mod = theConstructors[i].getModifiers(); // 输出修饰域和方法名称
System.out.print(Modifier.toString(mod) +""+ className +"("); Class[] parameterTypes = theConstructors[i].getParameterTypes(); // 获取指定构造方法的参数的集合
for (int j =0; j < parameterTypes.length; j++) { // 输出打印参数列表
System.out.print(parameterTypes[j].getName());
if (parameterTypes.length > j+1) {
System.out.print(", ");
}
}
System.out.println(")");
}
} catch (Exception e) {
e.printStackTrace();
}
} /**
* 获取反射类中的构造方法
* 输出打印格式:"Modifier修饰域 构造方法名(参数类型列表)"
*/
public static void get_Reflection_Constructors(ReflectionTest r) { Class temp = r.getClass();
String className = temp.getName(); // 获取指定类的类名 try {
Constructor[] theConstructors = temp.getDeclaredConstructors(); // 获取指定类的公有构造方法 for (int i = 0; i < theConstructors.length; i++) {
int mod = theConstructors[i].getModifiers(); // 输出修饰域和方法名称
System.out.print(Modifier.toString(mod) + " " + className + "("); Class[] parameterTypes = theConstructors[i].getParameterTypes(); // 获取指定构造方法的参数的集合
for (int j = 0; j < parameterTypes.length; j++) { // 输出打印参数列表
System.out.print(parameterTypes[j].getName());
if (parameterTypes.length > j+1) {
System.out.print(", ");
}
}
System.out.println(")");
}
} catch (Exception e) {
e.printStackTrace();
}
}
2、获取类的成员方法
与获取构造方法的方式相同,存在四种获取成员方法的方式。
Method getMethod(String name, Class[] params) 根据方法名和参数,返回一个具体的具有public属性的方法
Method[] getMethods() 返回所有具有public属性的方法数组
Method getDeclaredMethod(String name, Class[] params) 根据方法名和参数,返回一个具体的方法(不分public和非public属性)
Method[] getDeclaredMethods() 返回该类中的所有的方法数组(不分public和非public属性)
/**
* 获取反射类的方法
* 打印输出格式:"RetType FuncName(paramTypeList)"
*/
public static void get_Reflection_Method(ReflectionTest r) { Class temp = r.getClass();
String className = temp.getName(); /*
* Note: 方法getDeclaredMethods()只能获取到由当前类定义的所有方法,不能获取从父类继承的方法
* 方法getMethods() 不仅能获取到当前类定义的public方法,也能得到从父类继承和已经实现接口的public方法
* 请查阅开发文档对这两个方法的详细描述。
*/
//Method[] methods = temp.getDeclaredMethods();
Method[] methods = temp.getMethods(); for (int i = 0; i < methods.length; i++) { // 打印输出方法的修饰域
int mod = methods[i].getModifiers();
System.out.print(Modifier.toString(mod) + " "); // 输出方法的返回类型
System.out.print(methods[i].getReturnType().getName()); // 获取输出的方法名
System.out.print(" " + methods[i].getName() + "("); // 打印输出方法的参数列表
Class[] parameterTypes = methods[i].getParameterTypes();
for (int j = 0; j < parameterTypes.length; j++) {
System.out.print(parameterTypes[j].getName());
if (parameterTypes.length > j+1) {
System.out.print(", ");
}
}
System.out.println(")");
}
}
在获取类的成员方法时,有一个地方值得大家注意,就是getMethods()方法和getDeclaredMethods()方法。
getMethods():用于获取类的所有的public修饰域的成员方法,包括从父类继承的public方法和实现接口的public方法;
getDeclaredMethods():用于获取在当前类中定义的所有的成员方法和实现的接口方法,不包括从父类继承的方法。
大家可以查考一下开发文档的解释:
getMethods() - Returns an array containing Method objects for all public methods for the class C represented by this Class.
Methods may be declared in C, the interfaces it implements or in the superclasses of C.
The elements in the returned array are in no particular order.
getDeclaredMethods() - Returns a Method object which represents the method matching the specified name and parameter types
that is declared by the class represented by this Class.
因此在示例代码的方法get_Reflection_Method(...)中,ReflectionTest类继承了Object类,实现了actionPerformed方法,并定义如下成员方法:
通过这两个语句执行后的结果不同:
a、Method[] methods = temp.getDeclaredMethods()执行后结果如下:
b、Method[] methods = temp.getMethods()执行后,结果如下:
3、获取类的成员变量(成员属性)
存在四种获取成员属性的方法
Field getField(String name) 根据变量名,返回一个具体的具有public属性的成员变量
Field[] getFields() 返回具有public属性的成员变量的数组
Field getDeclaredField(String name) 根据变量名,返回一个成员变量(不分public和非public属性)
Field[] getDelcaredField() 返回所有成员变量组成的数组(不分public和非public属性)
/**
* 获取反射类中的属性和属性值
* 输出打印格式:"Modifier Type : Name = Value"
* Note: 对于未初始化的指针类型的属性,将不输出结果
*/
public static void get_Reflection_Field_Value(ReflectionTest r) {
Class temp = r.getClass(); // 获取Class类的对象的方法之一
try {
System.out.println("public 属性");
Field[] fb = temp.getFields();
for (int i = 0; i < fb.length; i++) {
Class cl = fb[i].getType(); // 属性的类型
int md = fb[i].getModifiers(); // 属性的修饰域
Field f = temp.getField(fb[i].getName()); // 属性的值
f.setAccessible(true);
Object value = (Object)f.get(r);
// 判断属性是否被初始化
if (value == null) {
System.out.println(Modifier.toString(md) + " " + cl + " : " + fb[i].getName());
}
else {
System.out.println(Modifier.toString(md) + " " + cl + " : " + fb[i].getName() + " = " + value.toString());
}
}
System.out.println("public & 非public 属性");
Field[] fa = temp.getDeclaredFields();
for (int i = 0; i < fa.length; i++) {
Class cl = fa[i].getType(); // 属性的类型
int md = fa[i].getModifiers(); // 属性的修饰域
Field f = temp.getDeclaredField(fa[i].getName()); // 属性的值
f.setAccessible(true); // Very Important
Object value = (Object) f.get(r);
if (value == null) {
System.out.println(Modifier.toString(md) + " " + cl + " : " + fa[i].getName());
}
else {
System.out.println(Modifier.toString(md) + " " + cl + " : " + fa[i].getName() + " = " + value.toString());
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
4、获取类、属性、方法的修饰域
类Class、Method、Constructor、Field都有一个public方法int getModifiers()。该方法返回一个int类型的数,表示被修饰对象( Class、 Method、 Constructor、 Field )的修饰类型的组合值。
在开发文档中,可以查阅到,Modifier类中定义了若干特定的修饰域,每个修饰域都是一个固定的int数值,列表如下:
该类不仅提供了若干用于判断是否拥有某中修饰域的方法boolean isXXXXX(int modifiers),还提供一个String toString(int modifier)方法,用于将一个表示修饰域组合值的int数转换成描述修饰域的字符串。
五、如何调用类中的private方法
在介绍之前,先放一个代码吧,这段代码是参考其他文章的代码拷贝过来的,代码不算长,但是动态调用类的成员方法的过程讲解的通俗易懂。
package crazypebble.reflectiontest; import java.lang.reflect.Constructor;
import java.lang.reflect.Method; public class LoadMethod { /**
* 在运行时加载指定的类,并调用指定的方法
* @param cName Java的类名
* @param MethodName 方法名
* @param types 方法的参数类型
* @param params 方法的参数值
* @return
*/
public Object Load(String cName, String MethodName, String[] types, String[] params) { Object retObject = null; try {
// 加载指定的类
Class cls = Class.forName(cName); // 获取Class类的对象的方法之二 // 利用newInstance()方法,获取构造方法的实例
// Class的newInstance方法只提供默认无参构造实例
// Constructor的newInstance方法提供带参的构造实例
Constructor ct = cls.getConstructor(null);
Object obj = ct.newInstance(null);
//Object obj = cls.newInstance(); // 构建 方法的参数类型
Class paramTypes[] = this.getMethodTypesClass(types); // 在指定类中获取指定的方法
Method meth = cls.getMethod(MethodName, paramTypes); // 构建 方法的参数值
Object argList[] = this.getMethodParamObject(types, params); // 调用指定的方法并获取返回值为Object类型
retObject = meth.invoke(obj, argList); } catch (Exception e) {
System.err.println(e);
} return retObject;
} /**
* 获取参数类型,返回值保存在Class[]中
*/
public Class[] getMethodTypesClass(String[] types) {
Class[] cs = new Class[types.length]; for (int i = 0; i < cs.length; i++) {
if (types[i] != null || !types[i].trim().equals("")) {
if (types[i].equals("int") || types[i].equals("Integer")) {
cs[i] = Integer.TYPE;
}
else if (types[i].equals("float") || types[i].equals("Float")) {
cs[i] = Float.TYPE;
}
else if (types[i].equals("double") || types[i].equals("Double")) {
cs[i] = Double.TYPE;
}
else if (types[i].equals("boolean") || types[i].equals("Boolean")) {
cs[i] = Boolean.TYPE;
}
else {
cs[i] = String.class;
}
}
}
return cs;
} /**
* 获取参数Object[]
*/
public Object[] getMethodParamObject(String[] types, String[] params) { Object[] retObjects = new Object[params.length]; for (int i = 0; i < retObjects.length; i++) {
if(!params[i].trim().equals("")||params[i]!=null){
if(types[i].equals("int")||types[i].equals("Integer")){
retObjects[i]= new Integer(params[i]);
}
else if(types[i].equals("float")||types[i].equals("Float")){
retObjects[i]= new Float(params[i]);
}
else if(types[i].equals("double")||types[i].equals("Double")){
retObjects[i]= new Double(params[i]);
}
else if(types[i].equals("boolean")||types[i].equals("Boolean")){
retObjects[i]=new Boolean(params[i]);
}
else{
retObjects[i] = params[i];
}
}
} return retObjects;
}
}
要调用一个类的方法,首先需要一个该类的实例(当然,如果该类是static,就不需要实例了,至于原因,你懂得!)。
1、创建一个类的实例
在得到一个类的Class对象之后,我们可以利用类Constructor去实例化该对象。Constructor支持泛型,也就是它本身应该是Constructor<T>。这个类有一个public成员函数:T newInstance(Object... args),其中args为对应的参数,我们通过Constructor的这个方法来创建类的对象实例。
在代码LoadMethod.java和LoadMethodEx.java中,分别给出了两种实例化Class类的方法:一种是利用Constructor类调用newInstance()方法;另一种就是利用Class类本身的newInstance()方法创建一个实例。两种方法实现的效果是一样的。
// 利用newInstance()方法,获取构造方法的实例 // Class的newInstance方法,仅提供默认无参的实例化方法,类似于无参的构造方法 // Constructor的newInstance方法,提供了带参数的实例化方法,类似于含参的构造方法 Constructor ct = cls.getConstructor(null); Object obj = ct.newInstance(null); Object obj = cls.newInstance();
2、行为
Method类中包含着类的成员方法的信息。在Method类中有一个public成员函数:Object invoke(Object receiver, Object... args),参数receiver指明了调用对象,参数args指明了该方法所需要接收的参数。由于我们是在运行时动态的调用类的方法,无法提前知道该类的参数类型和返回值类型,所以传入的参数的类型是Object,返回的类型也是Object。(因为Object类是所有其他类的父类)
如果某一个方法是Java类的静态方法,那么Object receiver参数可以传入null,因为静态方法从不属于对象。
3、属性
对类的成员变量进行读写,在Field类中有两个public方法:
Object get(Object object),该方法可用于获取某成员变量的值
Void set(Object object, Object value),该方法设置某成员变量的值
其中,Object参数是需要传入的对象;如果成员变量是静态属性,在object可传入null。
六、对LoadMethod.java的优化处理
在上一节中给出的LoadMethod.java中,类LoadMethod对固定参数类型的方法进行了调用,并且参数类型是通过一个String[]数组传入,然后经过方法 getMethodTypesClass() 解析之后,才得到了参数的具体的类型。同时在getMethodTypesClass()和getMethodParamObject()方法中,通过对传入的字符串参数进行过滤后,再处理那些可以匹配中的参数类型,其他不能匹配的参数都做为String对象来处理。如果我们调用的方法所需要的参数不是简单类型的变量,而是自定义的类对象,或者List列表,再如果我们只知道类名和方法名,不知道方法的参数类型,那我们该如何处理这些情况呢?
因此,我对LoadMethod类进行了一定的优化处理。先附上代码:
package crazypebble.reflectiontest; import java.lang.reflect.Constructor;
import java.lang.reflect.Method; public class LoadMethodEx { /**
* 在运行时加载指定的类,并调用指定的方法
* @param cName Java的类名
* @param MethodName 方法名
* @param params 方法的参数值
* @return
*/
public Object Load(String cName, String MethodName, Object[] params) { Object retObject = null; try {
// 加载指定的类
Class cls = Class.forName(cName); // 获取Class类的对象的方法之二 // 利用newInstance()方法,获取构造方法的实例
// Class的newInstance方法只提供默认无参构造实例
// Constructor的newInstance方法提供带参的构造实例
Constructor ct = cls.getConstructor(null);
Object obj = ct.newInstance(null);
//Object obj = cls.newInstance(); // 根据方法名获取指定方法的参数类型列表
Class paramTypes[] = this.getParamTypes(cls, MethodName); // 获取指定方法
Method meth = cls.getMethod(MethodName, paramTypes);
meth.setAccessible(true); // 调用指定的方法并获取返回值为Object类型
retObject = meth.invoke(obj, params); } catch (Exception e) {
System.err.println(e);
} return retObject;
} /**
* 获取参数类型,返回值保存在Class[]中
*/
public Class[] getParamTypes(Class cls, String mName) {
Class[] cs = null; /*
* Note: 由于我们一般通过反射机制调用的方法,是非public方法
* 所以在此处使用了getDeclaredMethods()方法
*/
Method[] mtd = cls.getDeclaredMethods();
for (int i = 0; i < mtd.length; i++) {
if (!mtd[i].getName().equals(mName)) { // 不是我们需要的参数,则进入下一次循环
continue;
} cs = mtd[i].getParameterTypes();
}
return cs;
}
}
我们通过前面几节的一系列分析,只要我们知道了一个类的类名(包括其包的路径),那我们就可以通过Class类的一系列方法,得到该类的成员变量、构造方法、成员方法、以及成员方法的参数类型和返回类型、还有修饰域等信息。
如果我们已经知道某个类名和需要动态调用的方法名,怎样才能不用传入方法的参数类型就可以调用该方法呢?
在已知类名的情况下,我们可以打印输出该类的所有信息,当然包括类的成员方法;然后通过给定的方法名,对打印输出的方法名进行筛选,找到我们需要的方法;再通过该方法的Method对象,得到该方法的参数类型、参数数量、和返回类型。那么我们在外部动态调用该方法时,就不需要关心该类需要传入的参数类型了,只需要传入类名、方法名、参数值的信息即可。笔者实现了一个类LoadMethodEx,先从两个类的同一个方法需要的参数方面做一个对比:
1、LoadMethodEx类,少了一个参数(方法参数类型列表),本文直接从类LoadMethod内部获取该参数类型列表,不需要用户传入该信息,好处其实也不言而喻了。
2、方法的参数值:类LoadMethod是将所有的方法参数都做为一个String来传入,在传入再进行解析;而本文则直接使用Object类型做为参数类型,因为invoke(Object obj, Object...args)方法本身所需要的参数类型就是Object,避免了不必要的参数类型变换。
在调用LoadMethod的Load()方法时,用户只需要知道类名、方法名,并且将已经初始化的参数先向上转型为Object,然后传递给Load()方法即可。方法的返回值为Object,这个肯定是由用户根据自己的需要,再转换成自己所需的类型。
属性:
public 属性
public class java.lang.Integer : bInteger = 4
public class java.lang.String : strB = crazypebble
public & 非public 属性
private int : bInt = 0
public class java.lang.Integer : bInteger = 4
public class java.lang.String : strB = crazypebble
private class java.lang.String : strA 构造方法:
public crazypebble.reflectiontest.ReflectionTest()
protected crazypebble.reflectiontest.ReflectionTest(int, java.lang.String) 父类/接口:
父类: java.lang.Object
接口0: java.awt.event.ActionListener
接口1: java.io.Serializable 成员方法:
public int abc(int, java.lang.String)
public void actionPerformed(java.awt.event.ActionEvent)
public final native void wait(long)
public final void wait()
public final void wait(long, int)
public boolean equals(java.lang.Object)
public java.lang.String toString()
public native int hashCode()
public final native java.lang.Class getClass()
public final native void notify()
public final native void notifyAll() 反射机制调用方法:LoadMethod
crazypebble ---> 1-hello, android-1! 反射机制调用方法:LoadMethodEx
crazypebble ---> 2-hello, android-2?
返回结果:0
七、总结
关于反射机制,其实还有一个比较敏感的话题,就是反射机制带来我们的安全性问题。由于我在这方面研究的不是很深入,所以讲不好。大家有空可以跟踪一下在本文最后提供的两个链接,里面有一些介绍。
我们介绍了Java的反射机制,但是在Android平台下,反射机制具体有没有什么用途呢?答案是肯定的。推荐大家看一篇文章《利用Java反射技术阻止通过按钮关闭对话框》,这篇文章为CSDN推荐为精品文章,所以还是很值得一看的。我特地从CSDN转载过来供大家一起学习。
原链接:http://blog.csdn.net/nokiaguy/archive/2010/07/27/5770263.aspx
转载链接:http://www.cnblogs.com/crazypebble/archive/2011/04/13/2014297.html
程序实现的源码:
看完上面这篇文章之后,希望大家明确一点的是:反射机制通过void setAccessible(boolean flag)方法可以得到一个类的private的方法和属性,使用这些private的方法和属性,已经可以做一些超越限制的事情了。所以在使用过程,还需谨慎啊!
代码中对每一步都有详细的解释,但是由于注释部分太多,可能对阅读有一定的障碍,还请大家谅解。同时本文主要参考了一下两篇文章:
1、 http://zlb1986.iteye.com/blog/937781
2、 http://www.cnblogs.com/keis/archive/2011/03/29/1998736.html
在此感谢两位的文章为本文提供了一定的基础,为我学习Java的反射机制提供了很好的教程。本文也是一篇学习总结,如果本文对这两篇文章的作者有冒犯之处,请及时与本人联系。如果各位同学发现本文和代码的错误之处的话,还请指正,一起学习交流。
附:两个工程的下载地址,供大家一起学习研究。http://u.115.com/file/f68453a0ca
参考:
Java 类反射机制分析的更多相关文章
- 如何利用缓存机制实现JAVA类反射性能提升30倍
一次性能提高30倍的JAVA类反射性能优化实践 文章来源:宜信技术学院 & 宜信支付结算团队技术分享第4期-支付结算部支付研发团队高级工程师陶红<JAVA类反射技术&优化> ...
- Java技术——Java反射机制分析
)生成动态代理. 2. Java反射API 反射API用来生成在当前Java虚拟机中的类.接口或者对象的信息. Class类:反射的核心类,可以获取类的属性,方法等内容信息. Field类:Java. ...
- java的反射机制
一.java的反射机制浅谈 最近研究java研究得很给力,主要以看博文为学习方式.以下是我对java的反射机制所产生的一些感悟,希望各位童鞋看到失误之处不吝指出.受到各位指教之处,如若让小生好好感动, ...
- Java 动态代理机制分析及扩展
Java 动态代理机制分析及扩展,第 1 部分 王 忠平, 软件工程师, IBM 何 平, 软件工程师, IBM 简介: 本文通过分析 Java 动态代理的机制和特点,解读动态代理类的源代码,并且模拟 ...
- Java高新技术 反射机制
Java高新技术 反射机制 知识概要: (1)反射的基石 (2)反射 (3)Constructor类 (4)Field类 (5)Method类 (6)用反射方 ...
- java的反射机制浅谈(转)
原文链接:java的反射机制浅谈 一.java的反射机制浅谈 1.何谓反射机制 根据网文,java中的反射机制可以如此定义: JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性 ...
- Java 动态代理机制分析及扩展,第 1 部分
Java 动态代理机制分析及扩展,第 1 部分 http://www.ibm.com/developerworks/cn/java/j-lo-proxy1/ 本文通过分析 Java 动态代理的机制和特 ...
- 深入研究Java类装载机制
目录 1.为什么要研究java类装在机制? 2.了解类装载机制,对于我们在项目开发中有什么作用? 3.装载实现细节. 4.总结 一.为什么药研究Java类装载机制 java类加载机制,便于我们使用自定 ...
- Java中反射机制和Class.forName、实例对象.class(属性)、实例对象getClass()的区别
一.Java的反射机制 每个Java程序执行前都必须经过编译.加载.连接.和初始化这几个阶段,后三个阶段如下图: 其中
随机推荐
- AIX下安装bash
在AIX系统下,默认是没有安装bash环境的,对于经常操作的维护人员来说,非常不方便,所以下面我们来动手安装bash. 1.确认系统是否已安装bash 方法1:之间敲bash命令,若提示没有此命令则没 ...
- Badboy录制脚本参数化
Jmeter录制脚本多采用Badboy工具 简单参数修改 第一步,先录制场景: a.开始录制,打开浏览器www.sogou.com b.在输入框中输入文字“Badboy" c.回车,关闭录制 ...
- EXCEL数据导入dataset
一.开工必备 1.micorosoft office2007 2.VS2010.Oracle 11 二.界面 三.内部代码 (1)获取数据库连接,定义全局变量 private static strin ...
- 修改server 2008远程桌面端口
在“开始”-"运行"菜单里,输入regedit HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Terminal Serve ...
- 邮箱验证 各种邮箱的smtp
常见邮箱的SMTP设置 QQ 邮箱举例:(地址test@qq.com)(账号test)(密码***)(SMTP服务smtp.qq.com)(端口25)(注意:请手动开通SMTP功能,通过网页登录qq邮 ...
- php如何获取当前时间
$nowtime=date('Y-m-d'); 这样取出来的值默认为当天的零点,对于做一些数据统计的sql查询比较有用
- 关于prototype和__proto__ 以及 constructor的文字总结
//函数的construct 指向了 function Function(){} undefined //实例化的对象 constructor 指向 函数本身 undefined //每个函数都有pr ...
- Android Dex文件格式(一)
dex是Android平台上(Dalvik虚拟机)的可执行文件, 相当于Windows平台中的exe文件, 每个Apk安装包中都有dex文件, 里面包含了该app的所有源码, 通过反编译工具可以获取到 ...
- WizNote for linux installation
源一:没有用处 官网链接http://www.wiznote.com/download-wiznote-for-Linux. 源二:提供了源及安装方法 Fedora 中文社区软件源,具体位置在这里. ...
- C#获取本机公网IP
/// <summary> /// 获取本机公网IP /// </summary> /// <returns></returns> public sta ...