Java的反射

一.Class类
1. 在面向对象的世界里，万事万物皆对象。（Java语言中，静态成员，普通数据类型不是对象）。 类也是对象，类是java.lang.Class类的实例对象
2. 这个对象到底如何表示：三种表示方式Foo.class. new Foo().getClass(), Class.forName(“com.Foo”)
3. Class.forName(“类的全称”)
不仅表示了，类的类类型，还代表了动态加载类
编译时刻加载类是静态加载类，如new；运行时刻加载类是动态加载类，如该用法
4. 基本的数据类型
void关键字 都存在类类
5. Class类的基本API操作

package com.jerry.reflect;

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

public class test {
    public static void main(String[] args) {
        Class c1 = double.class;
        Class c2 = Double.class;

        System.out.println(c1.getSimpleName());
        System.out.println(c2.getName());
        c2 = String.class;
        //打印类的信息 包括类的成员函数 成员变量
        System.out.println("类名" + c2.getName());
        /**
         * Method类 方法对象
         * 一个成员方法就是一个Method对象
         * getMethods()方法获取的是所有public函数 包括继承
         * getDeclareMethods()获取该类自己的类方法 不管访问权限
         */
        Method[] ms = c2.getMethods();
        for(int i=0; i<ms.length; i++){
            //得到方法的返回值类型的类类型
            Class returnType = ms[i].getReturnType();
            System.out.print(returnType.getName());
            //得到方法名
            System.out.print(ms[i].getName() + "(");
            //得到参数类型 得到参数列表的类型的类类型
            Class[] paras = ms[i].getParameterTypes();
            for (Class class1 : paras) {
                System.out.print(class1.getName() + ",");
            }
            System.out.println(")");
        }

        /**
         * 成员变量也是对象
         * java.lang.reflect.Field
         * Field类封装了关于成员变量的操作
         * getField()方法获取的是所有的public的成员变量的信息
         * getDeclaredFields()方法获取的是所有自己的成员变量，不管private or public
         */
        Field[] fs = c2.getDeclaredFields();
        for (Field field : fs) {
            //得到成员变量的类型的类类型
            Class fieldType = field.getType();
            String typeName = fieldType.getName();
            //得到成员变量的名称
            String fieldName = field.getName();
            System.out.println(typeName + " " + fieldName);
        }

        /**
         *构造函数也是对象
         *java.lang.reflect.Constructor中封装了构造函数的信息
         *getConstructors获取所有的public的构造函数
         *getDeclaredConstructors获得所有的构造函数  
         */
        Constructor[] cs = c2.getDeclaredConstructors();
        for (Constructor constructor : cs) {
            System.out.print(constructor.getName() + "C");
            //获取构造函数的参数列表，等到参数列表的类类型
            Class[] paraTypes = constructor.getParameterTypes();
            for (Class class1 : paraTypes) {
                System.out.print(class1.getName()+",");
            }
            System.out.println(")");
        }
    }
}

二，方法的反射

1. 如何获取某个方法
   方法的名称和方法的参数列表才能唯一决定某个方法

2. 方法反射的操作
   method.invoke(对象，参数列表)

package com.jerry.reflect;

import java.lang.reflect.Method;

public class MethodReflect {
    public static void main(String[] args) {
        //要获取add(int,int)方法
        //1. 首先获取类的信息，然后获取类的类类型
        Foo f = new Foo();
        Class<? extends Foo> c = f.getClass();
        /*
         * 2. 获取方法 由名称和参数列表来决定
         * getMethod获取的是public方法
         * getDeclaredMethod自己声明的所有方法
         */
        try {
//          Method m = c.getMethod("add", new Class[]{int.class, int.class});
            Method m = c.getMethod("add", int.class, int.class);
            //方法的反射操作 是用m对象来进行方法调用， 和f.add调用效果相同
            //如何方法没有返回值返回null，有返回值返回具体的返回值
            Object o = m.invoke(f, 2, 40);
            System.out.println(o);
            m.invoke(f, new Object[]{1, 12});
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Foo{
    public int add(int a, int b){
        System.out.println(a + b);
        return a + b;
    }
}

三，泛型是在编辑时检测类型，字节码中是去泛型化的。所以可以通过反射的方式绕过类型检测。