java-反射

1.Class类介绍

在程序运行期间， Java 运行时系统始终为所有的对象维护一个被称为运行时的类型标识。 这个信息跟踪着每个对象所属的类。 虚拟机利用运行时类型信息选择相应的方法执行。
然而，可以通过专门的Java类访问这些信息。保存这些信息的类被称为Class, 这个名 字很容易让人混淆。 Object 类中的 getClass( ) 方法将会返回一个 Class 类型的实例。
将 forName 与 newlnstance 配合起来使用，可以根据存储在字符串中的,类名创建一个对象
String s = “java.util.Random”;
Object m = Class.forName(s).newlnstance();
获取Class对象的三种方式
1)Object ——> getClass();
2)任何数据类型（包括基本数据类型）都有一个“静态”的class属性
3)通过Class类的静态方法：forName（String className）(常用)

package com.picc.reflection;

public class GetClass {
    public static void main(String[] args) {
        Student student = new Student();
        Class<? extends Student> aClass = student.getClass();
        System.out.println(aClass);

        Class<Student> studentClass = Student.class;
        System.out.println(studentClass == aClass);
        try {
            Class<?> aClass1 = Class.forName("com.picc.reflection.Student");
            System.out.println(aClass1 == aClass);
        } catch(Exception e){
            e.printStackTrace();
        }
    }
}

注意：在运行期间，一个类，只有一个Class对象产生。

利用反射分析类的能力

在java.lang.reflect 包中有三个类 Field、Method 和 Constructor 分别用于描述类的域、方法和构造器。
这三个类都有一个叫做 getName 的方法, 用来返回项目的名称。
Field 类有一 个 getType 方法， 用来返回描述域所属类型的 Class 对象。
Method 和 Constructor 类有能够报告参数类型的方法，
Method 类还有一个可以报告返回类型的方法。
这个类还有一个叫 做 getModifiers 的方法， 它将返回一个整型数值， 用不同的位开关描述 public 和 static 这样 的修饰符使用状况。
另外,还可以利用 java.lang.reflect 包中的 Modifier 类的静态方法分析 getModifiers 返回的整型数值。还可以利用 Modifier.toString 方法将修饰符打印出来。
Class类中的getFields、getMethods和getConstructors方法将分别返回类提供的 public 域、方法和构造器数组， 其中包括超类的公有成员。
Class 类的 getDeclareFields、 getDeclareMethods 和 getDeclaredConstructors 方法将分别返回类中声明的全部域、 方法和构造器， 其中包括私有和受保护成员,但不包括超类的成员。

package com.picc.javarefelct;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Scanner;

public class ReflectionTest {
  public static void main(String[] args) {
    String name;
    if(args.length>0) {
      name =args[0];
    } else {
      Scanner scanner = new Scanner(System.in);
      System.out.println("Enter class name(e.g. java.util.Date:)");
      name=scanner.next();
    }

    try {
      Class<?> c1 = Class.forName(name);
      // 获取类的父类
      Class supercl = c1.getSuperclass();
      // 获取类的修饰符
      String modifiers = Modifier.toString(c1.getModifiers());
      if (modifiers.length() > 0)
        System.out.print(modifiers + " ");
      System.out.print("class "+ name);
      if (supercl != null && supercl != Object.class)
        System.out.print(" extends " + supercl.getName());
      System.out .print ("\n{\n") ;
      printConstructors (c1) ;
      System.out .println() ;
      printMethods(c1) ;
      System.out .println();
      printFields(c1) ;
      System.out .println("}");

    } catch (ClassNotFoundException e) {
      e.printStackTrace();
    }
  }

  public static void printConstructors(Class cl) {
    {
      //获取类的所有构造器
      Constructor[] constructors = cl.getDeclaredConstructors();
      for (Constructor c : constructors) {
        String name = c.getName();
        System.out.print("  ");
        String modifiers = Modifier.toString(c.getModifiers());
        if (modifiers.length() > 0)
          System.out.print(modifiers + " ");
        System.out.print(name + "(");
        //获取构造器中的参数的类型
        Class[] paramTypes = c.getParameterTypes();
        for (int j = 0; j < paramTypes.length; j++) {
          if (j > 0) System.out.print(", ");
          System.out.print(paramTypes[j].getName());
        }
        System.out.println(") ;");
      }
    }
  }

  public static void printMethods(Class c1) {
      //获取类中的所有方法
      Method[] methods = c1.getDeclaredMethods();
      for (Method m : methods) {
        // 获取方法的返回类型
        Class retType = m.getReturnType();
        // 获取方法名称
        String name = m.getName();
        System.out.print("  ");
        // 获取方法的修饰符
        String modifiers = Modifier.toString(m.getModifiers());
        if (modifiers.length() > 0)
          System.out.print(modifiers + "");
        System.out.print(retType.getName() + "  " + name + "(");
        Class[] paramTypes = m.getParameterTypes();
        for (int j = 0; j < paramTypes.length; j++) {
          if (j > 0)
            System.out.println(", ");
          System.out.print(paramTypes[j].getName());
        }
        System.out.println(") ;");
      }
  }
  public static void printFields(Class cl) {
    //获取类中的所有的属性，包括修饰符/类型/名称
    Field[] fields = cl.getDeclaredFields();
    for (Field f : fields) {
      Class type = f.getType();
      String name = f.getName();
      System.out.print("  ");
      String modifiers = Modifier.toString(f.getModifiers());
      if (modifiers.length() > 0)
        System.out.println(modifiers + " ");
      System.out.println(type.getName() + " " + name + ";");
    }
  }
}

当访问一个私有属性， get 方法将会抛出一个
IllegalAccessException。只有利用 get 方法才能得到可访问域的值。除非拥有访问权限，否则
Java 安全机制只允许査看任意对象有哪些域， 而不允许读取它们的值。
反射机制的默认行为受限于 Java 的访问控制。然而， 如果一个 Java 程序没有受到安
全管理器的控制， 就可以覆盖访问控制。 为了达到这个目的， 需要调用 Field、 Method 或
Constructor 对象的 setAccessible 方法。