您所在的位置:主页 > JAVA技术 >

非常好的Java反射例子

时间:2014-07-09 14:42来源:未知 作者:疯狂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();

  }

  }