Java反射机制简介

Java反射机制简单介绍---比较详细的代码实例分析

在学习编程的过程中，我觉得不止要获得课本的知识，更多的是通过学习技术知识提高解决问题的能力，这样我们才能走在最前方，更多Java学习，请浏览疯狂java官网。

　　Java反射在我们Java学习的过程中是非常重要的知识点。可能有些同学认为这个学习起来不容易理解，其实就我个人而言还是比较简单，学习起来也比较容易理解。下面我给大家总结一下Java反射学习的要点，同时给出几个比较好的例子。
　　1、Java反射的概念
　　反射含义：可以获取正在运行的Java对象。
　　2、Java反射的功能
　　1)可以判断运行时对象所属的类
　　2)可以判断运行时对象所具有的成员变量和方法
　　3)通过反射甚至可以调用到private的方法
　　4)生成动态代理
　　3、实现Java反射的类
　　1)Class：它表示正在运行的Java应用程序中的类和接口
　　2)Field：提供有关类或接口的属性信息，以及对它的动态访问权限
　　3)Constructor：提供关于类的单个构造方法的信息以及对它的访问权限
　　4)Method：提供关于类或接口中某个方法信息
　　注意：Class类是Java反射中最重要的一个功能类，所有获取对象的信息(包括：方法/属性/构造方法/访问权限)都需要它来实现
　　4、编写Java反射程序的步骤：
　　1)必须首先获取一个类的Class对象
　　例如：
　　Class c1 = Test.class;
　　Class c2 = Class.forName(“com.reflection.Test”);
　　Class c3 = new Test().getClass();
　　2)然后分别调用Class对象中的方法来获取一个类的属性/方法/构造方法的结构
　　注意：如果要能够正常的获取类中方法/属性/构造方法应该重点掌握如下的反射类
　　Field
　　Constructor
　　Method
　　示例：此程序例子告诉大家如何操作Class/Field/Constructor/Method等与Java反射相关的类
　　package com.reflection;
　　import java.lang.reflect.Constructor;
　　import java.lang.reflect.Field;
　　import java.lang.reflect.InvocationTargetException;
　　import java.lang.reflect.Method;
　　import java.lang.reflect.Modifier;
　　public class TestReflection {
　　private String username;
　　private String password;
　　private int[] age;
　　public void setUserName(String username) {
　　this.username = username;
　　}
　　private void setPassWord(String password) {
　　this.password = password;
　　}
　　public static void test01() throws ClassNotFoundException {
　　Class c1 = TestReflection.class;
　　Class c2 = Class.forName("com.reflection.TestReflection");
　　//获取指定的包名
　　String package01 = c1.getPackage().getName();
　　String package02 = c2.getPackage().getName();
　　System.out.println("package01 = " + package01);
　　System.out.println("package02 = " + package02);
　　//获取类的修饰符
　　int mod = c1.getModifiers();
　　String modifier = Modifier.toString(mod);
　　System.out.println("modifier = " + modifier);
　　//获取指定类的完全限定名
　　String className = c1.getName();
　　System.out.println("className = " + className);
　　//获取指定类的父类
　　Class superClazz = c1.getSuperclass();
　　String superClazzName = superClazz.getName();
　　System.out.println("superClazzName = " + superClazzName);
　　//获取实现的接口
　　Class[] interfaces = c1.getInterfaces();
　　for (Class t : interfaces) {
　　System.out.println("interfacesName = " + t.getName());
　　}
　　//获取指定类的成员变量
　　Field[] fields = c1.getDeclaredFields();
　　for (Field field : fields) {
　　modifier = Modifier.toString(field.getModifiers()); //获取每个
　　字段的访问修饰符
　　Class type = field.getType(); //获取字段的数据类型所对应的
　　Class对象
　　String name = field.getName(); //获取字段名
　　if (type.isArray()) { //如果是数组类型则需要特别处理
　　String arrType = type.getComponentType().getName() +
　　"[]";
　　System.out.println("" + modifier + " " + arrType + " "
　　+ name + ";");
　　} else {
　　System.out.println("" + modifier + " " + type + " " +
　　name + ";");
　　}
　　}
　　//获取类的构造方法
　　Constructor[] constructors = c1.getDeclaredConstructors();
　　for (Constructor constructor : constructors) {
　　String name = constructor.getName(); //构造方法名
　　modifier = Modifier.toString(constructor.getModifiers()); //获取访问修饰符
　　System.out.println("" + modifier +" " + name + "(");
　　Class[] paramTypes = constructor.getParameterTypes(); //获取构造方法中的参数
　　for (int i = 0; i < paramTypes.length; i++) {
　　if (i > 0) {
　　System.out.print(",");
　　}
　　if (paramTypes[i].isArray()) {
　　System.out.println(paramTypes
　　[i].getComponentType().getName()+"[]");
　　} else {
　　System.out.print(paramTypes[i].getName());
　　}
　　}
　　System.out.println(");");
　　}
　　//获取成员方法
　　Method[] methods = c1.getDeclaredMethods();
　　for (Method method: methods) {
　　modifier = Modifier.toString(method.getModifiers());
　　Class returnType = method.getReturnType(); //获取方法的返回类型
　　if (returnType.isArray()) {
　　String arrType = returnType.getComponentType
　　().getName()+"[]";
　　System.out.print(""+modifier+" " + arrType + " " +
　　method.getName() + "(");
　　} else {
　　System.out.print("" + modifier + " " +
　　returnType.getName() + " " + method.getName() + "(");
　　}
　　Class[] paramTypes = method.getParameterTypes();
　　for (int i = 0; i < paramTypes.length; i++) {
　　if (i > 0) {
　　System.out.print(",");
　　}
　　if (paramTypes[i].isArray()) {
　　System.out.println(paramTypes
　　[i].getComponentType().getName()+"[]");
　　} else {
　　System.out.print(paramTypes[i].getName());
　　}
　　}
　　System.out.println(");");
　　}
　　}
　　public static void test02() throws InstantiationException,
　　IllegalAccessException, SecurityException, NoSuchMethodException,
　　IllegalArgumentException, InvocationTargetException {
　　//反射调用方法，可以通过Method类的invoke方法实现动态方法的调用
　　//public Object invoke(Object obj, Object... args)
　　//第一个参数代表对象
　　//第二个参数代表执行方法上的参数
　　//若反射要调用类的某个私有方法，可以在这个私有方法对应的Mehtod对象上先
　　调用setAccessible(true)
　　Class c1 = TestReflection.class;
　　TestReflection t1 = (TestReflection) c1.newInstance(); //利用反射来创
　　建类的对象
　　System.out.println("username == " + t1.username);
　　System.out.println("password == " + t1.password);
　　Method method = c1.getDeclaredMethod("setUserName", String.class);
　　method.invoke(t1, "Java反射的学习");
　　System.out.println("username == " + t1.username);
　　method = c1.getDeclaredMethod("setPassWord", String.class);
　　method.setAccessible(true);
　　method.invoke(t1, "反射执行某个Private修饰的方法");
　　System.out.println("password == " + t1.password);
　　}
　　public static void main(String[] args) throws ClassNotFoundException,
　　SecurityException, IllegalArgumentException, InstantiationException,
　　IllegalAccessException, NoSuchMethodException, InvocationTargetException {
　　// test01();
　　test02();
　　}
　　}

Java反射机制主要提供了以下功能：

 在运行时判断任意一个对象所属的类；

在运行时构造任意一个类的对象；

在运行时判断任意一个类所具有的成员变量和方法；

在运行时调用任意一个对象的方法；生成动态代理。

1. 得到某个对象的属性

public Object getProperty(Object owner, String fieldName) throws Exception 

{

 Class ownerClass = owner.getClass();

 Field field = ownerClass.getField(fieldName); 

Object property = field.get(owner); return property;

 } 

Class ownerClass = owner.getClass()：得到该对象的Class。

Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。

Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。

2. 得到某个类的静态属性Java代码 

public Object getStaticProperty(String className, String fieldName) throws Exception

 { 

Class ownerClass = Class.forName(className); 

Field field = ownerClass.getField(fieldName); 

Object property = field.get(ownerClass);

 return property;

 }

 Class ownerClass = Class.forName(className) ：首先得到这个类的Class。

Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。

Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。

3. 执行某对象的方法

public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception

 {

 Class ownerClass = owner.getClass(); 

Class[] argsClass = new Class[args.length]; 

for (int i = 0, j = args.length; i < j; i++) {

 argsClass[i] = args[i].getClass();

 } 

Method method = ownerClass.getMethod(methodName,argsClass);

 return method.invoke(owner, args); 

}

 Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。

5～9行：配置参数的Class数组，作为寻找Method的条件。

Method method = ownerClass.getMethod(methodName, argsClass)：通过methodName和参数的argsClass（方法中的参数类型集合）数组得到要执行的Method。

method.invoke(owner, args)：执行该Method.invoke方法的参数是执行这个方法的对象owner，和参数数组args，

可以这么理解：owner对象中带有参数args的method方法。

返回值是Object，也既是该方法的返回值。

4. 执行某个类的静态方法Java代码 

public Object invokeStaticMethod(String className, String methodName, Object[] args) throws Exception 

{

Class ownerClass = Class.forName(className);

 Class[] argsClass = new Class[args.length]; 

for (int i = 0, j = args.length; i < j; i++) { 

argsClass[i] = args[i].getClass();

 } 

Method method = ownerClass.getMethod(methodName,argsClass); 

return method.invoke(null, args);

 } 

基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。

5. 新建实例Java代码 

public Object newInstance(String className, Object[] args) throws Exception 

{ 

Class newoneClass = Class.forName(className); 

Class[] argsClass = new Class[args.length];

for (int i = 0, j = args.length; i < j; i++) { 

argsClass[i] = args[i].getClass(); 

}

 Constructor cons = newoneClass.getConstructor(argsClass); 

return cons.newInstance(args); 

} 

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，直接通过newoneClass.newInstance()来实现。

Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。

第5～第9行：得到参数的Class数组。

Constructor cons = newoneClass.getConstructor(argsClass)：得到构造器。

cons.newInstance(args)：新建实例。

6. 判断是否为某个类的实例

public boolean isInstance(Object obj, Class cls)

 {

 return cls.isInstance(obj);

 } 

7. 得到数组中的某个元素

public Object getByArray(Object array, int index) { 

return Array.get(array,index);

 }