Java反射实践

作者: Serenity那年 | 来源:发表于2018-10-28 21:29 被阅读12次

一、概述

Java的反射机制是Java语言动态性的一种体现。反射机制是通过反射API来实现的，它允许程序在运行过程中（runtime）取得任何一个已知名称类的内部信息，包括其中的构造方法、声明的字段和定义的方法等。这不得不说是一个很强大的能力。

二、基本方法

说到反射的用法不得不提java.lang.Class类，通过该类的对象就的方法可以获取到该类中的构造方法、域和方法。对应的方法分别是getConstructor、getField和getMethod。这三个方法还有相应的getDeclaredXXX版本，区别在于getDeclaredXXX版本的方法会获取该类自身所声明的所有字段包括public, protected, default (package), 和 private，但不会获取继承下来的字段。

Java反射API位于java.lang.reflect包中。主要包括以下几类：

1.Constructor类：用来描述一个类的构造方法。
2.Field类：用来描述一个类的成员变量。
3.Method类：用来描述一个类的方法。
4.Modifer类：用来描述类内各元素的修饰符。
5.Array：用来对数组进行操作。
Constructor、Field和Method这三个类分别表示类中的构造方法、字段和方法。

三、获取类的构造方法

java.lang.Class提供了4种获取类构造方法的反射调用：

Constructor getConstructor(Class[] params) -通过指定构造方法里面的参数类型来获取指定的公共构造方法；
Constructor[] getConstructors() -获得类的所有公共构造函数；
Constructor getDeclaredConstructor(Class[] params) -获得使用特定参数类型的构造函数(不包含继承的构造方法)；
Constructor[] getDeclaredConstructors() -获得类的所有构造函数(不包含继承的构造方法)；
调用这些方法会返回一个或多个 java.lang.reflect.Constructor 对象。Constructor 类定义了newInstance 方法，它采用一组对象作为其唯一的参数，然后返回新创建的原始类实例。该组对象是用于构造函数调用的参数值。

3.1 获取类的Class对象

方式一：通过将目标类装入到虚拟机的方式获得该类的Class对象;

Class<?> cls=Class.forName("java.lang.String");

方式二：通过类或类的对象获取类的Class对象;

Class<?> cls=String.class;
或
String str="";
Class<?> cls=str.getClass()
Class<?> cls=Class.forName("java.lang.String");

3.2 根据需要调用Class对象的4种获取构造方法的一种，获取到类的构造方法

1.通过指定构造方法里面的参数类型来获取指定的公共构造方法;

  try {
            Class<?> aClass = Class.forName("java.lang.String");
            //1.获取里面有特殊参数类型的公共构造方法
            Class[] parameterTypes = {String.class};
            System.out.println("1.通过指定构造方法里面的参数类型来获取指定的公共构造方法");
            Constructor<?> constructor = aClass.getConstructor(parameterTypes);
            System.out.println("1---->constructor:"+constructor.toString());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        /**
         * 打印结果：
         * 1.通过指定构造方法里面的参数类型来获取指定的公共构造方法
         * 1---->constructor:public java.lang.String(java.lang.String)
         */

2.通过指定构造参数获取类的指定构造方法,不是public的也会得到（不包含继承的构造方法）

      try {
            Class<?> aClass = Class.forName("java.lang.String");
            Class[] parameterTypes = {char[].class, boolean.class};
            System.out.println("2.通过指定构造方法里面的参数类型获取指定的构造方法，该构造方法不是继承的");
            Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(parameterTypes);
            System.out.println("2---->declaredConstructor:"+declaredConstructor.toString());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
       /**
         * 打印结果：
         *2.通过指定构造方法里面的参数类型获取指定的构造方法，该构造方法不是继承的
         *2---->declaredConstructor:java.lang.String(char[],boolean)
         */

3.获取所有的公共构造方法

 String str = "";
        Class<? extends String> aClass = str.getClass();
        System.out.println("3.获取所有的公共构造方法：");
        Constructor<?>[] constructors = aClass.getConstructors();
        for (int i = 0 ;i<constructors.length;i++) {
            System.out.println("总共："+constructors.length+"，当前第"+(i+1)+"个"+constructors[i].toString());
        }
        /**
         * 打印结果如下：
         * 3.获取所有的公共构造方法：
         总共：15，当前第1个public java.lang.String(byte[],int,int)
         总共：15，当前第2个public java.lang.String(byte[],java.nio.charset.Charset)
         总共：15，当前第3个public java.lang.String(byte[],java.lang.String) throws java.io.UnsupportedEncodingException
         总共：15，当前第4个public java.lang.String(byte[],int,int,java.nio.charset.Charset)
         总共：15，当前第5个public java.lang.String(byte[],int,int,java.lang.String) throws java.io.UnsupportedEncodingException
         总共：15，当前第6个public java.lang.String(java.lang.StringBuilder)
         总共：15，当前第7个public java.lang.String(java.lang.StringBuffer)
         总共：15，当前第8个public java.lang.String(byte[])
         总共：15，当前第9个public java.lang.String(int[],int,int)
         总共：15，当前第10个public java.lang.String()
         总共：15，当前第11个public java.lang.String(char[])
         总共：15，当前第12个public java.lang.String(java.lang.String)
         总共：15，当前第13个public java.lang.String(char[],int,int)
         总共：15，当前第14个public java.lang.String(byte[],int)
         总共：15，当前第15个public java.lang.String(byte[],int,int,int)
         * 
         */

4.获取所有类的构造方法（不包含继承的）

 Class<String> stringClass = String.class;
        System.out.println("4.获取所有的构造方法，不包含继承的");
        Constructor<?>[] declaredConstructors = stringClass.getDeclaredConstructors();
        for (int i = 0 ;i<declaredConstructors.length;i++) {
            System.out.println("总共："+declaredConstructors.length+"，当前第"+(i+1)+"个"+declaredConstructors[i].toString());
        }
        /**
         * 打印结果如下：
         *4.获取所有的构造方法，不包含继承的
         总共：16，当前第1个public java.lang.String(byte[],int,int)
         总共：16，当前第2个public java.lang.String(byte[],java.nio.charset.Charset)
         总共：16，当前第3个public java.lang.String(byte[],java.lang.String) throws java.io.UnsupportedEncodingException
         总共：16，当前第4个public java.lang.String(byte[],int,int,java.nio.charset.Charset)
         总共：16，当前第5个public java.lang.String(byte[],int,int,java.lang.String) throws java.io.UnsupportedEncodingException
         总共：16，当前第6个java.lang.String(char[],boolean)
         总共：16，当前第7个public java.lang.String(java.lang.StringBuilder)
         总共：16，当前第8个public java.lang.String(java.lang.StringBuffer)
         总共：16，当前第9个public java.lang.String(byte[])
         总共：16，当前第10个public java.lang.String(int[],int,int)
         总共：16，当前第11个public java.lang.String()
         总共：16，当前第12个public java.lang.String(char[])
         总共：16，当前第13个public java.lang.String(java.lang.String)
         总共：16，当前第14个public java.lang.String(char[],int,int)
         总共：16，当前第15个public java.lang.String(byte[],int)
         总共：16，当前第16个public java.lang.String(byte[],int,int,int)
         */

5.获取类默认的构造方法

     Class<String> stringClass = String.class;
        System.out.println("5.获取类默认的构造方法");
        try {
            Constructor<String> constructor = stringClass.getConstructor();
            System.out.println("5---->默认的构造方法："+constructor.toString());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        /**
         * 打印结果：
         * 5.获取类默认的构造方法
         *5---->默认的构造方法：public java.lang.String()
         */

四、通过反射获取类的实例

上文中已经通过反射获取到类的构造方法也就是Constructor对象。Constructor对象提供了public T newInstance(Object ... initargs)方法，该方法返回类的实例，其中initargs作为调用类的构造方法的参数数组，反射API会根据数组中元素的类型和个数选择调用类的相应构造方法。

 Class<String> aClass = String.class;
        System.out.println("通过指定构造方法中参数类型，来获取指定的构造方法");
        Class[] paramterType = {char[].class, boolean.class};
        try {
            Constructor<String> declaredConstructor = aClass.getDeclaredConstructor(paramterType);
            System.out.println("declaredConstructor----->"+declaredConstructor.toString());
            //告诉虚拟机，当调用该构造方法时，不用进行访问权限的控制，也就是给反射开个绿灯;
            declaredConstructor.setAccessible(true);
            char[] chars = {'a',' ','s','t','u','d','e','n','t'};
            Object newInstance = declaredConstructor.newInstance(chars, false);
            System.out.println("-----object------->"+newInstance.toString());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        /**
         * 打印结果：
         * 通过指定构造方法中参数类型，来获取指定的构造方法
         *declaredConstructor----->java.lang.String(char[],boolean)
         *-----object------->a student
         */

上面代码中constructor2.setAccessible(true)的意思是告诉虚拟机，当调用该构造方法时，不用进行访问权限的控制，也就是给反射开个绿灯。相应地Method，Field以及Constructor类都直接或间接的继承了AccessibleObject类，该类提供了将反射的对象标记为在使用时取消默认 Java 语言访问控制检查的能力。所以说在使用Method，Field以及Constructor类的对象时，如果该对象所表示的方法或字段是非public的，那么在访问它之前需要调用 public void setAccessible(boolean flag)方法将该对象的访问控制权限取消，否则java的异常处理机制会告诉你 can not access a member of class。

五、通过反射获取和修改类中的字段

和获取类的构造方法相似的是Class类同样也提供了获取类中字段的4种调用：

1.Field getField(String name) – 获得命名的公共字段；
2.Field[] getFields() – 获得类的所有公共字段；
3.Field getDeclaredField(String name) – 获得类声明的命名的字段；
4.Field[] getDeclaredFields() – 获得类声明的所有字段；
同样getField与getFields可以获得当前类中以及继承的public字段，getDeclaredField与getDeclaredFields则可以获得当前类中声明的所有字段，但不能获取继承的字段。
java.lang.reflect.Field表示类中的字段，该类提供了getXXX 和 setXXX 方法，以及get 和 set 方法来获取和设置该字段的值。大家可以根据实际的字段类型自行选择一种适当的方法。先看一下一会要用到的Person类，该类是一个简单的JavaBean。

public class Person {
    public String sex ;
}


public class Student extends Person{
    private static int age ;
    private static int width ;
    private String name;
    private int height ;
     public static int getWidth() {
        return width;
    }

    public static void setWidth(int width) {
        Student.width = width;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    /**
     * 其他代码省略
     */

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", height=" + height +
                '}';
    }
}

5.1 获取指定字段

 Student student = new Student();
        Class<? extends Student> aClass = student.getClass();
        System.out.println("获取指定字段");
        try {
            Field field = aClass.getDeclaredField("height");
            field.setAccessible(true);
            field.set(student,20);
            System.out.println("----student--->"+student.toString());
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        /**
         * 打印结果：
         * ----student--->Student{name='null', height=20}
         */

5.2 获取类的所有字段
1.获取该类以及继承的所有公有字段;

 System.out.println("获取该类及继承的所有公有字段");
        Field[]fields=aClass.getFields();
        for (int i = 0; i < fields.length; i++) {
            System.out.println("总共："+fields.length+"当前第"+(i+1)+"个 "+fields[i].toString());
        }
        /**
         * 打印结果：
         * 获取该类及继承的所有公有字段
         * 总共：1当前第1个 public java.lang.String com.zcbl_videosurvey.test.Person.sex
         */

2.获取该类所有的字段

 System.out.println("获取该类的所有字段，不包含继承的");
        Field[]fields2=aClass.getDeclaredFields();
        for (int i = 0; i < fields2.length; i++) {
            System.out.println("总共："+fields2.length+"当前第"+(i+1)+"个 "+fields2[i].toString());
        }
        /**
         * 打印结果：
         *总共：3当前第1个 private static int com.zcbl_videosurvey.test.Student.age
         *总共：3当前第2个 private java.lang.String com.zcbl_videosurvey.test.Student.name
         *总共：3当前第3个 private int com.zcbl_videosurvey.test.Student.height
         */

需改字段

修非静态字段
非静态字段和方法属于类的对象所有，所以要修改类的非静态字段需要一个该类的对象。

 Student student = new Student();
        Class<? extends Student> aClass = student.getClass();
        System.out.println("获取指定字段");
        try {
            Field field = aClass.getDeclaredField("height");
            field.setAccessible(true);
            field.set(student,20);
            System.out.println("----student--->"+student.toString());
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        /**
         * 打印结果：
         * ----student--->Student{name='null', height=20}
         */

需要指出的是如果字段是非public的，需要在访问该字段前取消该字段的访问权限控制field.setAccessible(true)，那么对于一个final字段是否可以通过反射修改它的值呢，答案是肯定的，前提同样是在访问该字段前取消该字段的访问权限控制。但如果该字段既被final修饰又被static修饰，那么是无法修改的。

修改静态字段
和修改非静态字段相比，修改类的静态字段就要轻松的多了，因为静态字段属于类所有，所以在修改静态字段的时候就不需要再传递一个该类的对象了。

  System.out.println("修改静态字段");
        try {
            Field field = aClass.getDeclaredField("age");
            field.setAccessible(true);
            field.set(null,180);
            System.out.println("-------->"+field.get(null));
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        /**
         * 打印结果：
         * 修改静态字段
         *-------->180
         */

六、通过反射获取并调用类中的方法

Class类提供了以下4种方式来获取类中的方法：

1.Method getMethod(String name, Class[] params) – 使用特定的参数类型，获得命名的公共方法；
2.Method[] getMethods() – 获得类的所有公共方法；
3.Method getDeclaredMethod(String name, Class[] params) – 使用特写的参数类型，获得类声明的命名的方法；
4.Method[] getDeclaredMethods() – 获得类声明的所有方法；
与获取类中字段类似，前两个方法用于获取类中以及继承的所有公共方法。后两个方法用于获取当前类中（不包含继承）所有的方法。以上4种方法返回的是Method对象，Method类中提供了public Object invoke(Object obj, Object... args)通过该方法我们可以调用任何一个类的任何一个方法。invoke 方法使用两个参数，为调用提供类实例和参数值数组。

6.1 调用非静态方法

Method类中提供了public Object invoke(Object obj, Object... args)通过该方法我们可以调用任何一个类的任何一个方法。invoke 方法使用两个参数，为调用提供类实例和参数值数组。如果第二个参数没有，可以省略或者null或者new Object[0]；

 Student student = new Student();
        Class aClass = student.getClass();
        try {
            Method method = aClass.getMethod("setName", new Class[]{String.class});
            method.invoke(student, "wanglu");
            Method method1 = aClass.getMethod("getName", new Class[]{});
            //第二个参数代表的参数数组值，如果没有可以省略或者null或者new Object[0]
            Object invoke = method1.invoke(student);
            System.out.println("-------getName------>"+invoke.toString());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        /**
         * 打印结果：
         * -------getName------>wanglu
         */

6.2 调用静态方法

 Student student = new Student();
        Class<? extends Student> aClass = student.getClass();
        try {
            Method method = aClass.getMethod("setAge", new Class[]{int.class});;
            method.invoke(student, 20);

            Method method1 = aClass.getMethod("getAge", new Class[]{});
            Object invoke = method1.invoke(student);
            System.out.println("-----调用静态方法---->"+invoke.toString());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
      

        System.out.println("调用静态的方法");
        try {
            Class<?> cls2 = Class.forName("java.lang.String");
            Method method3=cls2.getMethod("valueOf", new Class[]{long.class});
            //静态方法属于类方法，所以调用的时候可以将invoke的第一参数为null,但是不能省略不写。
//            Object object2=method3.invoke(null, 123);
            Object object2=method3.invoke(student，123);
            System.out.println(object2.toString());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        /**
         * 打印结果：
         *-----调用静态方法---->20
         * 调用静态的方法
         * 123
         */

静态方法属于类方法，所以调用的时候可以将invoke的第一参数为null,但是不能省略不写。

七、通过反射动态创建和访问数组

Class<?>componentType=Class.forName("java.lang.String");
Object array=Array.newInstance(componentType, 10);
Array.set(array, 5, "通过反射动态创建和访问数组 ");
System.out.println(Array.get(array, 5));

上述代码中Array.newInstance(componentType, 10);表示创建一个componentType类型大小为10的数组。Array.set(array, 5, "通过反射动态创建和访问数组 ");表示将数组第6个元素修改为”通过反射动态创建和访问数组 “，Array.get(array, 5)表示访问数组中第6个元素的值。

七、反射实践完整代码

package com.zcbl_videosurvey.test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * Created by serenitynanian on 2018/2/23.
 */

public class Test {


    public static void main(String[] args) {
        //获取类的Class对象
//        getClassInstances();
        /**
         * 获取类的构造方法
         * Constructor getConstructor(Class[] params) -- 获取里面有特殊参数类型的公共构造方法；
         * Constructor[] getConstructors() -- 获取该类的所有公共的构造方法；
         * Constructor getDeclaredConstructor(Class[] params) -- 获取里面有特殊参数类型的构造方法（不包含继承的构造方法）；
         * Constructor[] getDeclaredConstructor() -- 获取该类的所有构造函数(不包含继承的构造方法）；
         */
//        getClassConstructor1();
//        getClassConstructor2();
//        getClassConstructor3();
//        getClassConstructor4();
//        getClassDefaultConstructor();

        //通过反射获取类的实例
//        getReflectClassInstances();

        //通过反射获取字段
//        getFiled();
        //调用非静态方法
//        invokeNoStaticMethod();
        //调用静态方法
        invokeStaticMethod();
    }

    private static void invokeStaticMethod() {
        Student student = new Student();
        Class<? extends Student> aClass = student.getClass();
        try {
            Method method = aClass.getMethod("setAge", new Class[]{int.class});;
            method.invoke(student, 20);

            Method method1 = aClass.getMethod("getAge", new Class[]{});
            Object invoke = method1.invoke(null);
            System.out.println("-----调用静态方法---->"+invoke.toString());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }


        System.out.println("调用静态的方法");
        try {
            Class<?> cls2 = Class.forName("java.lang.String");
            Method method3=cls2.getMethod("valueOf", new Class[]{long.class});
            Object object2=method3.invoke(null, 123);
            System.out.println(object2.toString());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        /**
         * 打印结果：
         *-----调用静态方法---->20
         * 调用静态的方法
         * 123
         */
    }


    private static void invokeNoStaticMethod() {
        Student student = new Student();
        Class aClass = student.getClass();
        try {
            Method method = aClass.getMethod("setName", new Class[]{String.class});
            method.invoke(student, "wanglu");
            Method method1 = aClass.getMethod("getName", new Class[]{});
            //第二个参数代表的参数数组值，如果没有可以省略或者null或者new Object[0]
            Object invoke = method1.invoke(student);
            System.out.println("-------getName------>"+invoke.toString());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        /**
         * 打印结果：
         * -------getName------>wanglu
         */
    }

    private static void getFiled() {
        Student student = new Student();
        Class<? extends Student> aClass = student.getClass();
//        System.out.println("获取指定字段");
//        try {
//            Field field = aClass.getDeclaredField("height");
//            field.setAccessible(true);
//            field.set(student,20);
//            System.out.println("----student--->"+student.toString());
//        } catch (NoSuchFieldException e) {
//            e.printStackTrace();
//        } catch (IllegalAccessException e) {
//            e.printStackTrace();
//        }
//        /**
//         * 打印结果：
//         * ----student--->Student{name='null', height=20}
//         */

//        System.out.println("获取该类及继承的所有公有字段");
//        Field[]fields=aClass.getFields();
//        for (int i = 0; i < fields.length; i++) {
//            System.out.println("总共："+fields.length+"当前第"+(i+1)+"个 "+fields[i].toString());
//        }
//        /**
//         * 打印结果：
//         * 获取该类及继承的所有公有字段
//         * 总共：1当前第1个 public java.lang.String com.zcbl_videosurvey.test.Person.sex
//         */

//        System.out.println("获取该类的所有字段，不包含继承的");
//        Field[]fields2=aClass.getDeclaredFields();
//        for (int i = 0; i < fields2.length; i++) {
//            System.out.println("总共："+fields2.length+"当前第"+(i+1)+"个 "+fields2[i].toString());
//        }
//        /**
//         * 打印结果：
//         *总共：3当前第1个 private static int com.zcbl_videosurvey.test.Student.age
//         *总共：3当前第2个 private java.lang.String com.zcbl_videosurvey.test.Student.name
//         *总共：3当前第3个 private int com.zcbl_videosurvey.test.Student.height
//         */

        System.out.println("修改指定的静态字段");
        try {
            Field field = aClass.getDeclaredField("age");
            field.setAccessible(true);
            field.set(null,180);
            System.out.println("-------->"+field.get(null));
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        /**
         * 打印结果：
         * 修改静态字段
         *-------->180
         */

    }

    private static void getReflectClassInstances() {
        Class<String> aClass = String.class;
        System.out.println("通过指定构造方法中参数类型，来获取指定的构造方法");
        Class[] paramterType = {char[].class, boolean.class};
        try {
            Constructor<String> declaredConstructor = aClass.getDeclaredConstructor(paramterType);
            System.out.println("declaredConstructor----->"+declaredConstructor.toString());
            //告诉虚拟机，当调用该构造方法时，不用进行访问权限的控制，也就是给反射开个绿灯;
            declaredConstructor.setAccessible(true);
            char[] chars = {'a',' ','s','t','u','d','e','n','t'};
            Object newInstance = declaredConstructor.newInstance(chars, false);
            System.out.println("-----object------->"+newInstance.toString());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        /**
         * 打印结果：
         * 通过指定构造方法中参数类型，来获取指定的构造方法
         *declaredConstructor----->java.lang.String(char[],boolean)
         *-----object------->a student
         */
    }

    private static void getClassDefaultConstructor() {
        Class<String> stringClass = String.class;
        System.out.println("5.获取类默认的构造方法");
        try {
            Constructor<String> constructor = stringClass.getConstructor();
            System.out.println("5---->默认的构造方法："+constructor.toString());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        /**
         * 打印结果：
         * 5.获取类默认的构造方法
         *5---->默认的构造方法：public java.lang.String()
         */
    }

    private static void getClassConstructor4() {
        Class<String> stringClass = String.class;
        System.out.println("4.获取所有的构造方法，不包含继承的");
        Constructor<?>[] declaredConstructors = stringClass.getDeclaredConstructors();
        for (int i = 0 ;i<declaredConstructors.length;i++) {
            System.out.println("总共："+declaredConstructors.length+"，当前第"+(i+1)+"个"+declaredConstructors[i].toString());
        }
        /**
         * 打印结果如下：
         *4.获取所有的构造方法，不包含继承的
         总共：16，当前第1个public java.lang.String(byte[],int,int)
         总共：16，当前第2个public java.lang.String(byte[],java.nio.charset.Charset)
         总共：16，当前第3个public java.lang.String(byte[],java.lang.String) throws java.io.UnsupportedEncodingException
         总共：16，当前第4个public java.lang.String(byte[],int,int,java.nio.charset.Charset)
         总共：16，当前第5个public java.lang.String(byte[],int,int,java.lang.String) throws java.io.UnsupportedEncodingException
         总共：16，当前第6个java.lang.String(char[],boolean)
         总共：16，当前第7个public java.lang.String(java.lang.StringBuilder)
         总共：16，当前第8个public java.lang.String(java.lang.StringBuffer)
         总共：16，当前第9个public java.lang.String(byte[])
         总共：16，当前第10个public java.lang.String(int[],int,int)
         总共：16，当前第11个public java.lang.String()
         总共：16，当前第12个public java.lang.String(char[])
         总共：16，当前第13个public java.lang.String(java.lang.String)
         总共：16，当前第14个public java.lang.String(char[],int,int)
         总共：16，当前第15个public java.lang.String(byte[],int)
         总共：16，当前第16个public java.lang.String(byte[],int,int,int)
         */
    }

    private static void getClassConstructor3() {
        String str = "";
        Class<? extends String> aClass = str.getClass();
        System.out.println("3.获取所有的公共构造方法：");
        Constructor<?>[] constructors = aClass.getConstructors();
        for (int i = 0 ;i<constructors.length;i++) {
            System.out.println("总共："+constructors.length+"，当前第"+(i+1)+"个"+constructors[i].toString());
        }
        /**
         * 打印结果如下：
         * 3.获取所有的公共构造方法：
         总共：15，当前第1个public java.lang.String(byte[],int,int)
         总共：15，当前第2个public java.lang.String(byte[],java.nio.charset.Charset)
         总共：15，当前第3个public java.lang.String(byte[],java.lang.String) throws java.io.UnsupportedEncodingException
         总共：15，当前第4个public java.lang.String(byte[],int,int,java.nio.charset.Charset)
         总共：15，当前第5个public java.lang.String(byte[],int,int,java.lang.String) throws java.io.UnsupportedEncodingException
         总共：15，当前第6个public java.lang.String(java.lang.StringBuilder)
         总共：15，当前第7个public java.lang.String(java.lang.StringBuffer)
         总共：15，当前第8个public java.lang.String(byte[])
         总共：15，当前第9个public java.lang.String(int[],int,int)
         总共：15，当前第10个public java.lang.String()
         总共：15，当前第11个public java.lang.String(char[])
         总共：15，当前第12个public java.lang.String(java.lang.String)
         总共：15，当前第13个public java.lang.String(char[],int,int)
         总共：15，当前第14个public java.lang.String(byte[],int)
         总共：15，当前第15个public java.lang.String(byte[],int,int,int)
         *
         */
    }

    private static void getClassConstructor2() {
        try {
            Class<?> aClass = Class.forName("java.lang.String");
            Class[] parameterTypes = {char[].class, boolean.class};
            System.out.println("2.通过指定构造方法里面的参数类型获取指定的构造方法，该构造方法不是继承的");
            Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(parameterTypes);
            System.out.println("2---->declaredConstructor:"+declaredConstructor.toString());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        /**
         * 打印结果：
         *2.通过指定构造方法里面的参数类型获取指定的构造方法，该构造方法不是继承的
         *2---->declaredConstructor:java.lang.String(char[],boolean)
         */
    }

    //获取类的构造方法
    private static void getClassConstructor1() {
        try {
            Class<?> aClass = Class.forName("java.lang.String");
            //1.获取里面有特殊参数类型的公共构造方法
            Class[] parameterTypes = {String.class};
            System.out.println("1.通过指定构造方法里面的参数类型来获取指定的公共构造方法");
            Constructor<?> constructor = aClass.getConstructor(parameterTypes);
            System.out.println("1---->constructor:"+constructor.toString());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        /**
         * 打印结果：
         * 1.通过指定构造方法里面的参数类型来获取指定的公共构造方法
         * 1---->constructor:public java.lang.String(java.lang.String)
         */
    }

    //获取类的Class对象
    private static void getClassInstances() {
        //1.方式一：通过将目标类装入到虚拟机的方式获取该类的Class对象;
        //此方式通常会用在：无法直接引用目标类的情况；
        try {
            Class<?> aClass = Class.forName("java.lang.String");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //方式二：通过类或类的对象获取类的Class对象
        Class<String> stringClass1 = String.class;
        //或者下面的方式
        String str = "";
        Class<? extends String> stringClass2 = str.getClass();

    }


}