java之反射

java之反射
一、Java Reflection
     Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法
①Java反射机制提供的功能
    在运行时判断任意一个对象所属的类
    在运行时构造任意一个类的对象
    在运行时判断任意一个类所具有的成员变量和方法
    在运行时调用任意一个对象的成员变量和方法
    生成动态代理
②反射相关的主要API：
    java.lang.Class:代表一个类
    java.lang.reflect.Method:代表类的方法
    java.lang.reflect.Field:代表类的成员变量
    java.lang.reflect.Constructor:代表类的构造方法
二、Class 类
①Class本身也是一个类
    java.lang.Class:是反射的源头。
    我们创建了一个类，通过编译（javac.exe）,生成对应的.class文件。之后我们使用java.exe加载（JVM的类加载器完成的）
    此.class文件，此.class文件加载到内存以后，就是一个运行时类，存在在缓存区。那么这个运行时类本身就是一个Class的实例！
    1.每一个运行时类只加载一次！
    2.有了Class的实例以后，我们才可以进行如下的操作：
        1）*创建对应的运行时类的对象
        2）获取对应的运行时类的完整结构（属性、方法、构造器、内部类、父类、所在的包、异常、注解、...）
        3）*调用对应的运行时类的指定的结构(属性、方法、构造器)
        4）反射的应用：动态代理
②Class类的常用方法
    static Class  forName(String name) ：加载并返回指定类名 name 的 Class 对象
    Object newInstance() ：调用缺省构造函数，返回该Class对象的一个实例
    String getName() ：返回此Class对象所表示的实体（类、接口、数组类、基本类型或void）名称
    Class getSuperClass()：返回当前Class对象的父类的Class对象
    Class [] getInterfaces() ：获取当前Class对象的接口
    ClassLoader getClassLoader() ：返回该类的类加载器
    Constructor[] getConstructors()：返回一个包含某些Constructor对象的数组
    Field[] getFields()：返回Field对象的一个数组
    Method getMethod(String name,Class  …  paramTypes)：返回一个Method对象，此对象的形参类型为paramType
③实例化Class类对象(四种方法)
1）前提：若已知具体的类，通过类的class属性获取，该方法 最为安全可靠，程序性能最高
       实例：Class clazz = String.class;
2）前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象
       实例：Class clazz = new String().getClass();
3）前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName(类的全类名)获取，可能抛出ClassNotFoundException
       实例：Class clazz = Class.forName(“java.lang.String”);
4）其他：通过类加载器去加载
       ClassLoader loader = this.getClass().getClassLoader();
       Class clazz4 = loader.loadClass(“java.lang.String”);
④了解：类的加载过程
当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化
  1)将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成
  2)将类的二进制数据合并到JRE中
  3)JVM负责对类进行初始化
⑤了解：ClassLoader类加载器
类加载器是用来把类(class)装载进内存的。JVM 规范定义了两种类型的类加载器：
启动类加载器(bootstrap)和用户自定义加载器(user-defined class loader)。
JVM在运行时会产生3个类加载器组成的初始化加载器层次结构
  1)引导类加载器：用C++编写的，是JVM自带的类加载器，负责Java平台核心库，用来加载核心类库。该加载器无法直接获取
  2)扩展类加载器：负责jre/lib/ext目录下的jar包或 –D java.ext.dirs 指定目录下的jar包装入工作库
  3)系统类加载器：负责java –classpath 或 –D java.class.path所指的目录下的类与jar包装入工作 ，是最常用的加载器
    //1.获取一个系统类加载器
    ClassLoader classloader = ClassLoader.getSystemClassLoader();
    System.out.println(classloader);
    //2.获取系统类加载器的父类加载器，即扩展类加载器
    classloader = classloader.getParent();
    //3.获取扩展类加载器的父类加载器，即引导类加载器
    classloader = classloader.getParent();
    //4.测试当前类由哪个类加载器进行加载
    classloader = Class.forName("exer2.ClassloaderDemo").getClassLoader();
    //5.测试JDK提供的Object类由哪个类加载器加载
    classloader = Class.forName("java.lang.Object").getClassLoader();
    //*6.关于类加载器的一个主要方法：getResourceAsStream(String str):获取类路径下的指定文件的输入流
    InputStream in = this.getClass().getClassLoader().getResourceAsStream("exer2\\test.properties");
三、创建类对象并获取类的完整结构
①创建类的对象：调用Class对象的newInstance()方法
要  求：1）类必须有一个无参数的构造器。
 2）类的构造器的访问权限需要足够。
若没有无参的构造器，只能在操作的时候明确的调用类中的构造方法，并将参数传递进去之后，才可以实例化操作。步骤如下：
        1）通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器
        2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
        3）调用Constructor类的newInstance(object ... args)
②通过反射调用类的完整结构
②①获取对应的运行时类的属性 java.lang.reflect.Field
     1)Field[] getFields():只能获取到运行时类中及其父类中声明为public的属性
     2)Field[] getDeclaredFields():获取运行时类本身声明的所有的属性
     3)Field getField(String fieldName):获取运行时类中声明为public的指定属性名为fieldName的属性
     4)Field getDeclaredField(String fieldName):获取运行时类中指定的名为fieldName的属性,可以获取所有的属性，包括private属性
     5)获取属性的各个部分的内容(权限修饰符  变量类型 变量名)
          1.获取每个属性的权限修饰符
       int i = feild.getModifiers();返回代表修饰符的一个整数
       String str1 = Modifier.toString(i);通过Modifier的toString()将数值转化为字符串
   2.获取属性的类型
       Class type = feild.getType();：返回属性类型的Class对象
   3.获取属性名
       String str = feild.getName();返回属性的名称
     6)修改属性值方法一 (public String name；)
                Class clazz = Person.class;
         //1.获取指定的属性getField(String fieldName):获取运行时类中声明为public的指定属性名为fieldName的属性
  Field name = clazz.getField("name");
  //2.创建运行时类的对象
  Person p = (Person)clazz.newInstance();
  System.out.println(p);
  //3.将运行时类的指定的属性赋值
  name.set(p,"Jerry");
     7)修改属性值方法二 (private int age；)
          //getDeclaredField(String fieldName):获取运行时类中指定的名为fieldName的属性
  Field age = clazz.getDeclaredField("age");
   //由于属性权限修饰符的限制，为了保证可以给属性赋值，需要在操作前使得此属性可被操作。
  age.setAccessible(true);
  age.set(p,10);
②②获取运行时类的方法 java.lang.reflect.Method
     1)Method[] getMethods():获取运行时类及其父类中所有的声明为public的方法
     2)Method[] getDeclaredMethods():获取运行时类本身声明的所有的方法
     3)Method getMethod(String methodName,Class ... params):获取运行时类中声明为public的指定的方法
     4)Method getDeclaredMethod(String methodName,Class ... params):获取运行时类中声明了的指定的方法
     5)获取方法的各个部分的内容（注解 权限修饰符 返回值类型 方法名 形参列表 异常）
         //1.注解
  Annotation[] ann = method.getAnnotations();
  //2.权限修饰符
  String str = Modifier.toString(method.getModifiers());
  //3.返回值类型
  Class returnType = method.getReturnType();
  //4.方法名
  String str = method.getName();
  //5.形参列表
  Class[] params = method.getParameterTypes();
  //6.异常类型
  Class[] exps = method.getExceptionTypes();
     6)调用运行时类中指定的方法一 [public void show()]
                Class clazz = Person.class;
  //getMethod(String methodName,Class ... params):获取运行时类中声明为public的指定的方法
  Method method = clazz.getMethod("show");
  Person p = (Person)clazz.newInstance();
  //调用指定的方法：Object invoke(Object obj,Object ... obj)
  Object returnVal = m1.invoke(p);  :返回调用方法的返回值
  System.out.println(returnVal);

  //对于运行时类中静态方法的调用[public static void info()]
  Method method = clazz.getMethod("info");
  method.invoke(Person.class);
     7)调用运行时类中指定的方法二 [private int show(String nation,int age)] 
         //getDeclaredMethod(String methodName,Class ... params):获取运行时类中声明了的指定的方法
  Method method = clazz.getDeclaredMethod("display",String.class,int.class);
  //由于属性权限修饰符的限制，为了保证可以给属性赋值，需要在操作前使得此属性可被操作。 
  method.setAccessible(true);
  Object value = method.invoke(p,"CHN",10);
  System.out.println(value);
②③获取运行时类的构造器 java.lang.reflect.Constructor
      1)public Constructor<T>[] getConstructors()返回此 Class 对象所表示的类的所有public构造方法。
      2)public Constructor<T>[] getDeclaredConstructors()返回此 Class 对象表示的类声明的所有构造方法
      3)public Constructor<T> getConstructor(Class<?>... parameterTypes) :返回指定的public的构造器
      4)public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes):返回类中声明了的指定的构造器，包括private构造器
      5)调用运行时类中指定的构造器一
                String className = "com.lang.String";
  Class clazz = Class.forName(className);
   //创建对应的运行时类的对象。使用newInstance()，实际上就是调用了运行时类的空参的构造器。
  //要想能够创建成功：①要求对应的运行时类要有空参的构造器。②构造器的权限修饰符的权限要足够。
  Object obj = clazz.newInstance();
  String p = (String)obj;
      6)调用运行时类中指定的构造器二
                String1 className = "com.lang.String1";
  Class clazz = Class.forName(className);

                Constructor cons = clazz.getConstructor(String.class,int.class);
                String1 p = (String1)cons.newInstance("小三",20);
  
  Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);
  cons.setAccessible(true);
  String1 p = (String1)cons.newInstance("小三",20);
②④获取运行时类的注解
  Class clazz = String.class;
  Annotation[] anns = clazz.getAnnotations();
  for(Annotation a : anns){
   System.out.println(a);
  }
②⑤获取运行时类所在的包
  Class clazz = String.class;
  Package pack = clazz.getPackage();
  System.out.println(pack);
 
②⑥获取运行时类的实现的接口
  Class clazz = Person.class;
  Class[] interfaces = clazz.getInterfaces();
  for(Class i : interfaces){
   System.out.println(i);
  }
 
②⑦*.获取运行时类的父类的泛型
  Class clazz = Person.class;
  Type type1 = clazz.getGenericSuperclass();
  
  ParameterizedType param = (ParameterizedType)type1;
  Type[] ars = param.getActualTypeArguments();
  
  System.out.println(((Class)ars[0]).getName());
②⑧获取带泛型的父类
  Class clazz = Person.class;
  Type type1 = clazz.getGenericSuperclass();
  System.out.println(type1);
 
②⑨获取运行时类的父类
  Class clazz = Person.class;
  Class superClass = clazz.getSuperclass();
  System.out.println(superClass);