Java 反射

官方文档的描述，反射通常用于需要检查或修改 Java 虚拟机中运行的应用程序的运行时行为的程序。反射是一种功能强大的技术，可以使应用程序执行不可能执行的操作。

1. 获取类对象的几种方式

所有反射操作的入口都是 java.lang.Class。所以，我们首先要知道怎么去获取到 Class，即类对象。根据代码是否有权访问对象、类的名称、类型或现有类，有几种方法可以获得 Class。

1.1 Object.getClass()

如果有类的实例，则可以直接 getClass() 方法获取对应的 Class。getClass 是 Obejct 类中的方法，所以只要是继承自 Obejct 的类都可以调用。

例如：

public class Box {

    public void method() {
    }
}

public static void main(String[] args) {
     Box box = new Box();
     Class clazz = box.getClass();
}

1.2 ".class"

如果没有类的实例，但是类是可以访问到的，那么可以通过追加 .class 来获得这个类。这也是获取基本类型的最简单方法。

例如：

Class clazzBox = Box.class;
Class clazzBoolean = boolean.class; //不能通过 getClass() 获取

1.3 Class.forName()

如果类的包名和类名是已知的，那么可以通过静态方法 Class.forName() 获取类对象。此方法可能会抛出 ClassNotFoundException 异常。

例如：

try {
     Class box = Class.forName("testjava.Box");
} catch (ClassNotFoundException e) {
     e.printStackTrace();
}

1.4 TYPT 属性

对于基本类型，最方便快捷地获取 Class 的方式是通过追加 .class。但是，我们还可以通过另外一种方式获取基本类型的类对象。
我们知道，每一种基本类型都会对应的有一个包装类，比如，boolean 的包装类为 Boolean、int 的包装类为 Integer。每一个包装类中，都一个静态的 TYPE 变量，它就是用来存放包装类对应的基本类型的类对象的。
所以，我们可以这样获取基本类型的类对象：

Class clazzInt = Integer.TYPE;

if (clazzInt == int.class) { //int.class 和 Integer.TYPE 是相同的
    System.out.println("true");
}

2. 获取构造器实例化对象和属性信息

2.1 构造函数

构造函数用于创建类的实例，完成一些初始化操作，构造方法不能被继承。
构造函数可能包含名称、修饰符、参数和一系列的异常等。可以通过 java.lang.reflect.Constructor 提供的方法获取到相应的信息。

public class Box {

    private Box() {
        System.out.println("***** Box()");
    }

    public Box(String name) {
        System.out.println("***** Box(name) name:" + name);
    }
}


public static void main(String[] args) {
        Class boxClass = Box.class;
        //获取 Box 类的所有构造方法
        Constructor[] allConstructor = boxClass.getDeclaredConstructors();
        for (Constructor constructor : allConstructor) {
            System.out.println("***** " + constructor.toGenericString());
            //获取构造方法的参数
            Type[] gpTypes = constructor.getGenericParameterTypes();
            for (int j = 0; j < gpTypes.length; j++) {
                System.out.println("***** GenericParameterType " + j + " :" + gpTypes[j]);
            }
            System.out.println("***** --------------------------");
        }
    }

打印

***** private testjava.Box()
***** --------------------------
***** public testjava.Box(java.lang.String)
***** GenericParameterType 0 :class java.lang.String
***** --------------------------

通过反射实例化对象，有两种方式：

直接使用 Class.newInstance() 实例化对象。
先获取到类的构造方法 Constructor，然后通过 Constructor.newInstance() 实例化对象。

两者相比，通常建议使用后者，因为前者调用的是无参数的构造函数实例化对象，并且需要无参构造函数是可访问的。而后者对参数没有要求，并且就算是 private 的也是可以调用的。

例如：

public class Box {

    private String name;

    private Box() {
        name = "Box";
        System.out.println("***** Box()");
    }

    public Box(String name) {
        this.name = name;
        System.out.println("***** Box(name) name:" + name);
    }

    public String getName() {
        return name;
    }
}

public static void main(String[] args) {
        Class boxClass = Box.class;
        //获取 Box 类的所有构造方法
        Constructor[] allConstructor = boxClass.getDeclaredConstructors();
        Constructor constorZeroParams = null; //无参构造方法
        Constructor constorParams = null;     //有参构造方法
        for (Constructor constructor : allConstructor) {
            if (constructor.getGenericParameterTypes().length == 0) {
                constorZeroParams = constructor;
            } else {
                constorParams = constructor;
            }
        }
        if (constorZeroParams != null) {
            constorZeroParams.setAccessible(true);
            try {
                Box box = (Box) constorZeroParams.newInstance();
                //Box box = Box.class.newInstance(); //会报异常 java.lang.IllegalAccessException: Class testjava.TestJava can not access a member of class testjava.Box with modifiers "private"
                System.out.println("name:" + box.getName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (constorParams != null) {
            constorParams.setAccessible(true);
            try {
                Box box = (Box) constorParams.newInstance("haha");
                System.out.println("name:" + box.getName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

打印结果：

***** Box()
name:Box
***** Box(name) name:haha
name:haha

2.2 方法

java.lang.reflect.Method 类提供了 API 去获取方法的信息：修饰符、返回值、参数、注解信息和异常等。

public class Box {

    private String name;

    private Box() {
        name = "Box";
        System.out.println("***** Box()");
    }

    public Box(String name) {
        this.name = name;
        System.out.println("***** Box(name) name:" + name);
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("***** setName(name) name:" + name);
    }

    public String getName() {
        return name;
    }

    private void method1() {
        System.out.println("private 方法");
    }

    public void method2() {
        System.out.println("public 方法");
    }

    public int method3() {
        System.out.println("带返回值 方法");
        return 0;
    }

    public <E extends RuntimeException> void method4() throws E {
        System.out.println("异常 方法");
    }

    public static void staticMethod() {
        System.out.println("静态 方法");
    }
}

public static void main(String[] args) {
        Class boxClass = Box.class;
        Method[] allMethods = boxClass.getMethods();
        for (Method method : allMethods) {
            System.out.println("---------------------");
            //获取所有的方法
            System.out.println("method: " + method.toGenericString());
            //参数类型
            Type[] gpTypes = method.getGenericParameterTypes();
            Class[] pTypes = method.getParameterTypes();
            for (int i = 0; i < gpTypes.length; i++) {
                System.out.println("pType: " + pTypes[i]);
                System.out.println("gpType: " + gpTypes[i]);
            }
            //异常类型
            Class<?>[] xType  = method.getExceptionTypes();
            Type[] gxType = method.getGenericExceptionTypes();
            for (int i = 0; i < xType.length; i++) {
                System.out.println("ExceptionType: "+ xType[i]);
                System.out.println("GenericExceptionType: " + gxType[i]);
            }
            //返回值
            Class<?> returnClazz = method.getReturnType();
            System.out.println("return class: " + returnClazz);
        }
        System.out.println("---------------------");

        //获取指定的方法并使用
        try {
            Method method = boxClass.getDeclaredMethod("setName", String.class);
            method.setAccessible(true);
            //成员方法，需要先实例化一个对象
            Constructor constructor = null;
            Constructor[] constructors = boxClass.getDeclaredConstructors();
            for (Constructor cons : constructors) {
                if (cons.getGenericParameterTypes().length == 0) {
                    constructor = cons;
                    break;
                }
            }
            constructor.setAccessible(true);
            Box box = (Box) constructor.newInstance();
            method.invoke(box, "method");
            System.out.println("name: " + box.getName());

            //调用静态函数，不需要实例化对象
            Method staticMethod = boxClass.getDeclaredMethod("staticMethod");
            staticMethod.invoke(null, null);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }