反射

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
反射机制的特征：动态性

有反射VS无反射
一：无反射时可对类的操作

创建类的对象实例；
通过对象实例调用内部的属性方法。
在类的外部不能通过该类对象调用其内部私有的结构（体现了面向对象的封装性）
二：有反射是可对类的操作

1. 通过反射创建类的对象
2. 通过反射调用其对象的属性方法
3. 可调用类的所有结构
4. 可调用注解。

java.long.Class的理解
一：.类的加载过程：
程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)。 接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件 加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此 运行时类，就作为Class的一个实例。Class的实例就对应着一个运行时类。加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式 来获取此运行时类。
获取运行时类的方式

调用运行时类的属性（类名.class）
假设此类为Person类，以下举例权益Person为例
Class clazz1 = Person.class;
1
通过运行时类的对象创建运行时类（getClass()）
Person p1 = new Person();
Class clazz2 = p1.getClass();
1
2
调用class是的静态方法：forName（String classPath）
其中classPath为全类名
Class clazz = Class.forName(“全类名”);
1
类的加载器ClassLoader
ClassLoader classLoader = Person.class.getClassLoader();
Class clazz4 = classLoader.loadClass(“全类名”);
1
2
newInstance（）方法
调用此方法，创建对应的运行时类的对象。
使用此方法的注意点

运行时类必须提供空参的构造器；
空参的构造器的访问权限设置为public。
Class clazz = Person.class;
Person obj = clazz.newInstance();
1
2
通过反射获取运行时类的完整结构
一：运行时类的属性（getFields() VS getDeclaredFields()）

getFields():获取当前运行时类及其父类中声明为public访问权限的属性
getDeclaredFields()获取当前运行时类中声明的所有属性。（不包含父类中声明的属性）
Class clazz = Person.class;

    //获取属性结构
    //getFields():获取当前运行时类及其父类中声明为public访问权限的属性
    Field[] fields = clazz.getFields();
    for(Field f : fields){
        System.out.println(f);
    }
    System.out.println();

    //getDeclaredFields():获取当前运行时类中声明的所有属性。（不包含父类中声明的属性）
    Field[] declaredFields = clazz.getDeclaredFields();
    for(Field f : declaredFields){
        System.out.println(f);
    }

二：权限修饰符（getModifiers()）数据类型（getType（））变量名（getName（））

    Class clazz = Person.class;
    Field[] declaredFields = clazz.getDeclaredFields();
    for(Field f : declaredFields){
        //1.权限修饰符
        int modifier = f.getModifiers();
        System.out.print(Modifier.toString(modifier) + "\t");

        //2.数据类型
        Class type = f.getType();
        System.out.print(type.getName() + "\t");

        //3.变量名
        String fName = f.getName();
        System.out.print(fName);

        System.out.println();
    }

获取运行时类的方法（getMethods() VS getDeclaredMethods()）
getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
getDeclaredMethods():获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
Class clazz = Person.class;

    //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
    Method[] methods = clazz.getMethods();
    for(Method m : methods){
        System.out.println(m);
    }
    System.out.println();
    //getDeclaredMethods():获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
    Method[] declaredMethods = clazz.getDeclaredMethods();
    for(Method m : declaredMethods){
        System.out.println(m);
    }

/**
@注解
权限修饰符 返回值类型 方法名(参数类型1 形参名1,…) throws XxxException{}
*/
Class clazz = Person.class;
Method[] declaredMethods = clazz.getDeclaredMethods();
for(Method m : declaredMethods){
//1.获取方法声明的注解
Annotation[] annos = m.getAnnotations();
for(Annotation a : annos){
System.out.println(a);
}

        //2.权限修饰符
        System.out.print(Modifier.toString(m.getModifiers()) + "\t");

        //3.返回值类型
        System.out.print(m.getReturnType().getName() + "\t");

        //4.方法名
        System.out.print(m.getName());
        System.out.print("(");
        //5.形参列表
        Class[] parameterTypes = m.getParameterTypes();
        if(!(parameterTypes == null && parameterTypes.length == 0)){
            for(int i = 0;i < parameterTypes.length;i++){

                if(i == parameterTypes.length - 1){
                    System.out.print(parameterTypes[i].getName() + " args_" + i);
                    break;
                }

                System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
            }
        }

        System.out.print(")");

        //6.抛出的异常
        Class[] exceptionTypes = m.getExceptionTypes();
        if(exceptionTypes.length > 0){
            System.out.print("throws ");
            for(int i = 0;i < exceptionTypes.length;i++){
                if(i == exceptionTypes.length - 1){
                    System.out.print(exceptionTypes[i].getName());
                    break;
                }

                System.out.print(exceptionTypes[i].getName() + ",");
            }
        }

获取运行时类中指定的结构、属性、方法、构造器
属性的获取
创建运行时类的对象
getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
保证当前属性是可访问的setAccessible(true)；
设置指定对象的此属性值
Class clazz = Person.class;

    //1.创建运行时类的对象
    Person p = (Person) clazz.newInstance();

    //2. getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
    Field name = clazz.getDeclaredField("name");

    //3.保证当前属性是可访问的
    name.setAccessible(true);
    //4.获取、设置指定对象的此属性值
    name.set(p,"Tom");

    System.out.println(name.get(p));

运行时类中的指定的方法
创建运行时类的对象
获取指定的某个方法的getDeclaredMethod（参数1，参数2）
参数1：指明获取方法方法的名称；
参数2：指明获取的方法的形参列表
保证当前方法是可访问的setAccessible(true)
调用方法的invoke（参数1，参数2）
参数1：方法调用者
参数2：需要赋值的实参
Class clazz = Person.class;

    //1.创建运行时类的对象
    Person p = (Person) clazz.newInstance();

    /*
    2.获取指定的某个方法
    getDeclaredMethod():参数1 ：指明获取的方法的名称  参数2：指明获取的方法的形参列表
     */
    Method show = clazz.getDeclaredMethod("show", String.class);
    //3.保证当前方法是可访问的
    show.setAccessible(true);

    /*
    4. 调用方法的invoke():参数1：方法的调用者  参数2：给方法形参赋值的实参
    invoke()的返回值即为对应类中调用的方法的返回值。
     */
    Object returnValue = show.invoke(p,"CHN"); //String nation = p.show("CHN");
    System.out.println(returnValue);

运行时类的指定构造器