具体使用

  1. try {
  2.             Class clazz =Class.forName("test.Person");
  3.             //1 创建对象
  4.             Person person = (Person)clazz.newInstance();
  5.             //2 获取属性对象,获取运行时类和所有父类中public的属性
  6.             Field[] fields =  clazz.getFields();
  7.             //运行时类中的所有属性（不含父类）
  8.             Field[] fields1 =  clazz.getDeclaredFields();
  9.             for(Field field:fields1){
  10.                 //权限修饰符
  11.                 Modifier.toString(field.getModifiers());
  12.                 //类型
  13.                 field.getType();
  14.                 //变量名
  15.                 field.getName();
  16.             }
  17.             //3 获取运行时类及其父类中所有public的方法
  18.             Method[] methods = clazz.getMethods();
  19.             //运行时类中的所有方法（不含父类）
  20.             Method[] methods1 = clazz.getDeclaredMethods();
  21.             for(Method method:methods){
  22.                 //获取方法生成的注解(元注解Retention声明为RUNTIME才能获取到)
  23.                 method.getAnnotations();
  24.                 //权限修饰符
  25.                 Modifier.toString(method.getModifiers());
  26.                 //返回值类型
  27.                 method.getReturnType().getName();
  28.                 //方法名称
  29.                 method.getName();
  30.                 //获取形参列表
  31.                 Class[] parameterTypes = method.getParameterTypes();
  32.                 for(Class parameterType:parameterTypes){
  33.                     parameterType.getName();
  34.                 }
  35.                 //抛出的异常
  36.                 Class[] exceptionTypes =  method.getExceptionTypes();
  37.                 for(Class exceptionType:exceptionTypes){
  38.                     exceptionType.getName();
  39.                 }
  41.             }
  42.             //4 获取当前运行时类声明为public的构造器
  43.             Constructor[] constructors=  clazz.getConstructors();
  44.             //获取当前运行时类所有的构造器
  45.             clazz.getDeclaredConstructors();
  46.             //5 获取运行时类的父类
  47.             clazz.getSuperclass();
  48.             //6 获取带泛型的父类
  49.             Type genericSuperclass =  clazz.getGenericSuperclass();
  50.             ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
  51.             //获取泛型类型
  52.             parameterizedType.getActualTypeArguments();
  53.             //7.获取运行时类实现的接口
  54.             clazz.getInterfaces();
  55.             //8.获取运行时类所在的包
  56.             clazz.getPackage();
  57.             //9.获取运行时类声明的注解
  58.             clazz.getAnnotations();
  59.             /**
  60.              * 调用运行时类中指定的结构：属性、方法、构造器
  61.              */
  62.             //1 获取指定的属性,要求声明为public
  63.             Field age = clazz.getField("age");
  64.             //设置属性值
  65.             age.set(person, 1);
  66.             //获取属性值
  67.             int personAge = age.getInt(person);
  68.             //获取私有的属性
  69.             Field pvAge = clazz.getDeclaredField("age");
  70.             //设置该属性才能修改
  71.             pvAge.setAccessible(true);
  72.             pvAge.set(person, 1);
  73.             pvAge.get(person);
  74.             //2 操作指定的方法
  75.             Method setName =  clazz.getDeclaredMethod("setName",String.class);
  76.             setName.setAccessible(true);
  77.             setName.invoke(person, "张三");
  78.             //调用静态方法
  79.             Method show =  clazz.getDeclaredMethod("show");
  80.             show.setAccessible(true);
  81.             show.invoke(clazz); 
  82.             //操作指定的构造器
  83.             Constructor constructor= clazz.getDeclaredConstructor(String.class);
  84.             constructor.setAccessible(true);
  85.             constructor.newInstance("张三"); 
  87.         } catch (Exception e) {
  88.             // TODO Auto-generated catch block
  89.             e.printStackTrace();
  90.         }