深入理解Java中的反射机制

java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

一：class类

在面向对象的世界里，万物皆对象。类也是对象，类是java.lang.class类的实例对象。

class类的实例表示正在运行的 java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 class 对象。

基本的 java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 class 对象。

class 没有公共构造方法。class 对象是在加载类时由 java 虚拟机以及通过调用类加载器中的 defineclass 方法自动构造的。

上面来自于jdk的罗里吧嗦，下面我来说下自己的体会：

类不是抽象的，类是具体的！

类是.class字节码文件，要想获取一个class实例对象，首先需要获取.class字节码文件！

然后调用class对象的一些方法，进行动态获取信息以及动态调用对象方法！

二：类类型

新建一个foo类。foo这个类也是实例对象，是class的实例对象。

不知道你是否在意过类的声明与方法的声明：

public class foo{
       foo(){
          //构造方法
       }
}
public foo method(){
    //...
}

我们知道public后跟返回类型，也就可以知道class也是一个类型。

如何表示class的实例对象？

    public static void main(string[] args) {
        //foo的实例对象，new 就出来了
        foo foo1 = new foo();
        
        //如何表示？
        //第一种：告诉我们任何一个类都有一个隐含的静态成员变量class
        class c1 = foo.class;
        
        //第二种:已经知道该类的对象通过getclass方法
        class c2 = foo1.getclass();
        system.out.println(c1 == c2);
        
        //第三种：动态加载
        class c3 = null;
        try {
            c3 = class.forname("cn.zyzpp.reflect.foo");
        } catch (classnotfoundexception e) {
            e.printstacktrace();
        }
        
        system.out.println(c2 == c3);
    }

上述打印结果全是true

尽管 c1或c2 都代表了foo的类类型，一个类只能是class类的一个实例变量。

我们完全可以通过类的类类型（class类型）创建类的实例对象。

        //此时c1 c2 c3为class的实例对象
        try {
//            foo foo = (foo)c1.newinstance();
            foo foo = (foo)c3.newinstance();
            foo.print();
        } catch (instantiationexception e) {
            e.printstacktrace();
        } catch (illegalaccessexception e) {
            e.printstacktrace();
        }

静态加载

new 创建对象是静态加载类，在编译时刻就需要加载所有的可能使用到的类 。

动态加载

使用 class.forname("类的全称") 加载类称作为动态加载 。

编译时刻加载类是静态加载类，运行时刻加载类是动态加载类。

举个例子

定义office类

public class office {
    public void print() {
        system.out.println("office");
    }
}

定义loading类

public class loading {

    public static void main(string[] args) {
        try {
            //在运行时再动态加载类
            //arg[0] 为java执行命令时传的参数
            class<?> a = class.forname(args[0]);
            office office = (office) a.newinstance();
            office.print();
        } catch (classnotfoundexception e) {
            e.printstacktrace();
        } catch (illegalaccessexception e) {
            e.printstacktrace();
        } catch (instantiationexception e) {
            e.printstacktrace();
        }
    }

}

执行过程

d:\>javac -encoding utf-8 loading.java office.java

d:\>java loading office
office

通过class a=class.forname(arg[0])动态加载获取类，因编译时不知道使用哪个类，因此编译没有加载任何类，直接通过编译，运行时，根据 java loading office （office是一个类类型/类，下标arg[0]）,去确定a是哪个类。这就是动态加载。如果office类不存在，此时运行会报错。这就是为何有时候会出现编译通过，运行报错的原因。

这里需要有一个具体的概念，类就是.class字节码文件的实例对象！

动态加载一个好处，就是可以随时增加需要编译的类。例如把office改造为抽象类或接口，定义不同的子类，动态选择加载。

三：类的反射

通过上面的三种方法获取到类的类类型，就可以获取到该类的成员方法，成员变量，方法参数注释等信息。

方法对象是method类，一个成员方法就是一个method对象。

方法	解释
getmethods()	返回该类继承以及自身声明的所有public的方法数组
getdeclaredmethods()	返回该类自身声明的所有public的方法数组，不包括继承而来

成员变量也是对象，是java.lang.reflect.field对象，field类封装了关于成员变量的操作。

方法	解释
getfields()	获取所有的public的成员变量信息，包括继承的。
getdeclaredfields()	获取该类自己声明的成员变量信息，public，private等

获取java语言修饰符（public、private、final、static）的int返回值，再调用modifier.tostring()获取修饰符的字符串形式，注意该方法会返回所有修饰符。

方法	解释
getmodifiers()	以整数形式返回由此对象表示的字段的 java 语言修饰符。

获取注释

方法	解释
getannotations()	返回此元素上存在的所有注释。
getdeclaredannotations()	返回直接存在于此元素上的所有注释。

构造函数也是对象，是java.lang.reflect.constructor的对象。

方法	解释
getconstructors()	返回所有public构造方法
getdeclaredconstructors()	返回类的所有构造方法，不止public

完整示例

    private void printclassmessage(object obj){
        //要获取类的信息，首先获取类的类类型
        class clazz = obj.getclass();
        //获取类的名称
        system.out.println(modifier.tostring(clazz.getmodifiers())+" "+ clazz.getclass().getname()+" "+clazz.getname()+"{");
        
        system.out.println("----构造方法----");
        
        //构造方法
        constructor[] constructors = clazz.getdeclaredconstructors();
        for (constructor constructor: constructors){
            //构造方法修饰符与名字
            system.out.print(modifier.tostring(constructor.getmodifiers())+" "+constructor.getname()+"(");
            //构造函数的所有参数类型
            class[] parametertypes = constructor.getparametertypes();
            for (class c: parametertypes){
                system.out.print(c.getname()+", ");
            }
            system.out.println("){}");
        }
        
        system.out.println("----成员变量----");
        
        //成员变量
        field[] fields = clazz.getdeclaredfields();
        for (field field: fields){
            system.out.println(" "+modifier.tostring(field.getmodifiers())+" "+field.gettype().getname() + " " + field.getname()+";");
        }
        
        system.out.println("----成员方法----");
        
        //method类，方法对象,一个成员方法就是一个method对象
        method[] methods = clazz.getdeclaredmethods();
        for (method method : methods){
            //获取方法返回类型
            class returntype = method.getreturntype();
            //获取方法上的所有注释
            annotation[] annotations = method.getannotations();
            for (annotation annotation: annotations){
                //打印注释类型
                system.out.println(" @"+annotation.annotationtype().getname()+" ");
            }
            //打印方法声明
            system.out.print(" "+modifier.tostring(returntype.getmodifiers())+" "+returntype.getname()+" "+method.getname()+"(");
            //获取方法的所有参数类型
            class<?>[] parametertypes = method.getparametertypes();
            //获取方法的所有参数
            parameter[] parameters = method.getparameters();
            for (parameter parameter: parameters){
                //参数的类型，形参（全是arg123..）
                system.out.print(parameter.gettype().getname()+" "+parameter.getname()+", ");
            }
            system.out.println(")");
        }
        system.out.println("}");
    }

以string对象为例，打印结果：

public final java.lang.class java.lang.string{
----构造方法----
public java.lang.string([b, int, int, ){}
 java.lang.string([c, boolean, ){}
----成员变量----
 private final [c value;
 private int hash;
----成员方法----
 @java.lang.deprecated 
 public abstract final void getbytes(int arg0, int arg1, [b arg2, int arg3, )
 ......
}

四：方法的反射

定义了一个类foo用于测试

public class foo{
    public void print(string name,int num) {
        system.out.println("i am "+name+" age "+num);
    }
}

目标：通过反射获取该方法，传入参数，执行该方法！

1.获取类的方法就是获取类的信息，获取类的信息首先要获取类的类类型

class clazz = foo.class;

2.通过名称+参数类型获取方法对象

method method = clazz.getmethod("print", new class[]{string.class,int.class});

3.方法的反射操作是通过方法对象来调用该方法，达到和new foo().print()一样的效果

方法若无返回值则返回null

object o = method.invoke(new foo(),new object[]{"name",20});

五：通过反射认识泛型

    public static void main(string[] args) {
        arraylist<string> stringarraylist = new arraylist<>();
        stringarraylist.add("hello");
        arraylist arraylist = new arraylist();
        
        class c1 = stringarraylist.getclass();
        class c2 = arraylist.getclass();
        
        system.out.println(c1 == c2);

    }

打印结果为true

c1==c2的结果返回说明编译之后集合的泛型是去泛型化的。换句话说，泛型不同，对类型没有影响。

java中集合的泛型其实只是为了防止错误输入，只在编译阶段有效，绕过编译就无效。

验证

我们可以通过反射来操作，绕过编译。

    public static void main(string[] args) {
        arraylist<string> stringarraylist = new arraylist<>();
        stringarraylist.add("hello");
        arraylist arraylist = new arraylist();
        class c1 = stringarraylist.getclass();
        class c2 = arraylist.getclass();
        system.out.println(c1 == c2);

        try {
            method method = c1.getmethod("add",object.class);
            method.invoke(stringarraylist,20);
            system.out.println(stringarraylist.tostring());
        } catch (nosuchmethodexception e) {
            e.printstacktrace();
        } catch (illegalaccessexception e) {
            e.printstacktrace();
        } catch (invocationtargetexception e) {
            e.printstacktrace();
        }

    }

打印结果：

true
[hello, 20]