一：Java反射机制概述

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我可可以通过这个对象看到类的结构。这个对象就像一面镜子，透过镜子看到类的结构，所以，我们想象的称之为：反射。

二：理解Class类并获取Class实例（掌握）

（1）理解Class类

  1. 类的加载过程：程序经过javac.exe命令之后，会生成一个或多个字节码文件（.class结尾）。接着我们使用java.exe命令对某个字节码文件进行解释运行，相当于将某个字节码文件加载到内存中，此过程就称为类的加载。加载到内存中的类，我们称为运行时类，此运行时类，就作为Class的一个实例。
  2. 换句话说，Class的实例就对应着一个运行时类。

  3. 加载到内存中的运行时类，会缓存一定的时间，在此时间之内，我们可以通过不同的方式来获取此运行时类。

    （2）获取Class实例

    1. /**
    2. * 获取Class的实例的方式（前三种掌握，第四种了解）
    3. */
    4. public class ReflectionTest1 {
    5.  public static void main(String[] args) throws ClassNotFoundException {
    6.      test4();
    7.  }
    8.  //方式一:调用运行时类的属性：.class
    9.  public static void test1(){
    10.      Class<Person> clazz = Person.class;
    11.      System.out.println(clazz);//class cn.hgk.reflection.Person
    12.  }
    13.  //方式二：通过运行时类的对象，调用getClass()
    14.  public static void test2(){
    15.      Person p1 = new Person();
    16.      Class<? extends Person> clazz = p1.getClass();
    17.      System.out.println(clazz);//class cn.hgk.reflection.Person
    18.  }
    19.  //方式三：调用Class的静态方法：forName(String classPath)。（这种方式用的最多）
    20.  public static void test3() throws ClassNotFoundException {
    21.      Class clazz = Class.forName("cn.hgk.reflection.Person");//路径
    22.      System.out.println(clazz);//class cn.hgk.reflection.Person
    23.  }
    24.  //方式四：使用类的加载器：ClassLoader
    25.  public static void test4() throws ClassNotFoundException {
    26.      ClassLoader classLoader = ReflectionTest1.class.getClassLoader();
    27.      Class clazz = classLoader.loadClass("cn.hgk.reflection.Person");
    28.      System.out.println(clazz);//class cn.hgk.reflection.Person
    29.  }
    30. }

    三：类的加载与ClassLoader的理解

    （1）类的加载

    当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

  4. 类的加载：将类的class文件读入内存，并为之创建一个java.lang.Class对象，此过程由类加载器完成。

  5. 类的链接：将类的二进制数据合并到JRE中。

  6. 类的初始化：JVM负责对类进行初始化。

    （2）ClassLoader的理解

    类加载器的作用：

  7. 类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆内存中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

  8. 类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，他将维持加载（缓存）一段时间，不过JVM垃圾回收机制可以回收这些Class对象。

    1. /**
    2. * 使用ClassLoader加载配置文件
    3. *    Properties:用来读取配置文件
    4. */
    5. public class Test1 {
    6.  public static void main(String[] args) throws IOException {
    7.      Properties pros = new Properties();
    8.      //读取配置文件的方式一：
    9.      FileInputStream fis = new FileInputStream("src\\jdbc.properties");//此时的文件默认在当前的module下
    10.      pros.load(fis);
    12.      String user = pros.getProperty("user");
    13.      String password = pros.getProperty("password");
    14.      System.out.println("user="+user+",password="+password);
    15.  }
    16. }

    四：创建运行时类的对象（掌握）

    1. /**
    2. * 通过反射创建对应的运行时类的对象
    3. */
    4. public class NewInstanceTest {
    5.  public static void main(String[] args) throws IllegalAccessException, InstantiationException {
    6.      Class<Person> clazz = Person.class;
    7.      /**
    8.       * newInstance():调用此方法创建运行时类的对象,
    9.       * 其实newInstance()内部也调用了运行时类的空参构造器（只有通过构造器才能创建对象）
    10.       *    要想此方法正常的长剑运行时类的对象，要求;
    11.       *      1.运行时类必须提供空参的构造器
    12.       *      2.空参的构造器的访问权限得够。通常，设置为public
    13.       *    在javabean中要求提供一个public的空参构造器。原因：
    14.       *      1.便于通过反射，创建运行时类的对象。
    15.       *      2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器
    16.       */
    17.      Person person = clazz.newInstance();
    18.      System.out.println(person);
    19.  }
    20. }

    五：获取运行时类的完整结构

    1. /**
    2.   * 获取属性结构
    3.   */
    4.  public static void test1(){
    5.      Class<Person> clazz = Person.class;
    6.      //方式一：getFields():获取当前运行类及其父类中声明为public访问权限的属性
    7.      Field[] fields = clazz.getFields();
    8.      for (Field f : fields) {
    9.          System.out.println(f);
    10.      }
    11.      //方式二：getDeclaredFields():获取当前运行时类中声明的所有属性（不包含父类中的属性）
    12.      Field[] declaredFields = clazz.getDeclaredFields();
    13.      for (Field f : declaredFields) {
    14.          System.out.println(f);
    15.      }
    16.  }
    18.  /**
    19.   * 获取运行时类的属性的内部结构
    20.   */
    21.  public static void test2(){
    22.      Class<Person> clazz = Person.class;
    23.      Field[] declaredFields = clazz.getDeclaredFields();
    24.      for (Field f : declaredFields) {
    25.          //1.权限修饰符
    26.          int modifiers = f.getModifiers();
    27.          System.out.println(Modifier.toString(modifiers));
    28.          //2.数据类型
    29.          Class type = f.getType();
    30.          System.out.println(type+"\t");
    31.          //3.变量名
    32.          String name = f.getName();
    33.          System.out.println(name);
    34.      }
    35.  }
    36.  /**
    37.   * 获取运行时类的方法结构
    38.   */
    39.  public static void test3(){
    40.      Class<Person> clazz = Person.class;
    41.      //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
    42.      Method[] m = clazz.getMethods();
    43.      for (Method method : m) {
    44.          System.out.println(method);
    45.      }
    46.      //**********
    47.      //getDeclaredMethods():获取当前运行时类中声明的所有方法（不包含父类中的方法）
    48.      Method[] declaredMethods = clazz.getDeclaredMethods();
    49.      for (Method d : declaredMethods) {
    50.          System.out.println(d);
    51.      }
    52.  }
    53.  /**
    54.   * 获取运行时类的方法的内部结构
    55.   *
    56.   * @Xxxx
    57.   * 权限修饰符 返回值类型 方法名（参数类型1 形参名1，...） throws XxxException{}
    58.   */
    59.  public static void test4(){
    60.      Class<Person> clazz = Person.class;
    61.      Method[] declaredMethods = clazz.getDeclaredMethods();
    62.      for (Method m : declaredMethods) {
    63.          //1.获取方法声明的注解
    64.          Annotation[] annos = m.getAnnotations();
    65.          for (Annotation a : annos) {
    66.              System.out.println(a);
    67.          }
    68.          //2.权限修饰符
    69.          System.out.println(Modifier.toString(m.getModifiers())+"\t");
    70.          //3.返回值类型
    71.          System.out.println(m.getReturnType().getName()+"\t");
    72.          //4.方法名
    73.          System.out.println(m.getName());
    74.          //5.形参
    75.          System.out.println("(");
    76.          Class[] parameterTypes = m.getParameterTypes();
    77.          System.out.println(")");
    78.      }
    79.  }

    六：调用运行时类的指定结构（掌握）

    （1）属性

    1. /**
    2.   * 调用运行时类中指定的结构(属性、方法、构造器)
    3.   */
    4.  //1.属性(方式一):getField()。（不需要掌握）
    5.  public static void test5() throws Exception {
    6.      Class<Person> clazz = Person.class;
    7.      //创建运行时类的对象
    8.      Person p = clazz.newInstance();
    9.      //方法一：获取指定的属性(要求运行时类中属性的权限是public的)(因此通常不用这个方法)
    10.      Field id = clazz.getField("id");
    11.      /**
    12.       * 设置当前属性的值
    13.       *set():
    14.       *  参数一:指明设置哪个对象的属性
    15.       *  参数二：将此属性设置为多少
    16.       */
    17.      id.set(p,1001);
    18.      /**
    19.       * 获取当前属性的值
    20.       *set():
    21.       *  参数一:指明获取哪个对象的属性
    22.       */
    23.      int o = (int)id.get(p);
    24.      System.out.println(o);//1001
    25.  }
    26.  //1.属性(方式二)（不需要掌握）
    27.  public static void test6() throws Exception {
    28.      Class<Person> clazz = Person.class;
    29.      //创建运行时类的对象
    30.      Person p = clazz.newInstance();
    31.      //getDeclaredField("name"):获取运行时类指定变量名的属性
    32.      Field name = clazz.getDeclaredField("name");
    33.      //只有完成这个name.setAccessible(true);操作才可以修改权限为private的属性
    34.      name.setAccessible(true);//保证当前属性是可访问的
    35.      name.set(p,"hgk");
    36.      String o = (String)name.get(p);
    37.      System.out.println(o);
    38.  }

    （2）方法

    1. //2.方法(需要掌握)
    2.  public static void test7() throws Exception {
    3.      Class<Person> clazz = Person.class;
    4.      //创建运行时类的对象
    5.      Person p = clazz.newInstance();
    6.      /**
    7.       * 1.获取指定的某个方法
    8.       *   getDeclaredMethod():
    9.       *      参数一：指明获取的方法的名称
    10.       *      参数二：指明获取的方法的形参列表
    11.       */
    12.      Method show = clazz.getDeclaredMethod("show", String.class);
    13.      show.setAccessible(true);
    14.      /**
    15.       * invoke():
    16.       *  参数一:方法的调用者
    17.       *  参数二：给方法形参赋值的实参.
    18.       * invoke()的返回值即为对应类中调用的方法的返回值
    19.       */
    20.      String chn = (String) show.invoke(p, "CHN");
    21.      System.out.println(chn);
    22.      //******如何调用静态方法***********public static void info()
    23.      Method info = clazz.getDeclaredMethod("info");
    24.      show.setAccessible(true);
    25.      //如果调用的运行时类中的方法没有返回值，则此invoke()返回null
    26.      Object invoke = info.invoke(Person.class);
    27.      System.out.println(invoke);//null
    28.  }

    （3）构造器

    1. //3.构造器(不需要掌握)
    2.  public static void test8() throws Exception {
    3.      Class<Person> clazz = Person.class;
    4.      /*
    5.      1.获取指定的构造器
    6.      */
    7.      Constructor<Person> constructor = clazz.getDeclaredConstructor(String.class);
    8.      //2.保证此构造器是可访问的
    9.      constructor.setAccessible(true);
    10.      //3.调用此构造器创建运行时类的对象
    11.      Person person = constructor.newInstance("hgk");
    12.      System.out.println(person.toString());//Person{name='hgk', age=0, id=0}
    13.  }