Java反射详解

1. 简介


       Java在编译时候就必须知道所引用的类所在地方，但是在实际编程中，在某些场合，可能需要引用一个并不在编译空间的类，这个时候常规方法就很难实现了。在Java中，Class配合反射能够很好的解决这种场景。Java里面的反射可以帮助我们在运行程序时候加载、使用编译期间完全未知的class，简单来说就是Java可以加载一个运行时候才得知名称的class，获得其完整的构造，并生成实例化对象，对其成员变量赋值，调用其方法等等。


       在具体的研发中，通过反射获取类的实例，大大提高系统的灵活性和扩展性，同时由于反射的性能较低，而且它极大的破坏了类的封装性(通过反射获取类的私有方法和属性)，在大部分场景下并不适合使用反射，但是在大型的一些框架中，会大范围使用反射来帮助架构完善一些功能。


       上面说了一些简介，接下来直接就看看怎么使用反射来帮助我们获取class中的一些属性和方法吧。


2. 说明


反射机制中会用到一些类，在了解反射是如何使用之前，先介绍一下这些类。


类 说明
Class 在反射中表示内存中的一个Java类，Class可以代表的实例类型包括，类和接口、基本数据类型、数组
Object Java中所有类的超类
Constructor 封装了类的构造函数的属性信息，包括访问权限和动态调用信息
Field 提供类或接口的成员变量属性信息，包括访问权限和动态修改
Method 提供类或接口的方法属性信息，包括访问权限和动态调用信息
Modifier 封装了修饰属性， public、protected、static、final、synchronized、abstract等
注：Class本身就是一个类，Class就是这个类的名称(注意首字母是大写)；public class Demo {}，这里的class是作为关键字，来表明Demo是一个类


3. 获取属性


通过反射可以获取类的多种属性，并对其进行一些操作，例如获取其中的某个方法并调用。先定义一个基础的类，然后用反射获取这个类的一些信息吧。


接口，仅仅名声了一个eat()方法


public interface IHumanAction {
    void eat();
}
1
2
3
1
2
3
具体的类，注意类各个方法的修饰属性。


public class Human implements IHumanAction {
    private int age;
    public String name;


    public Human() {


    }


    Human(String name) {
        this.name = name;
    }


    protected Human(int age) {
        this.age = age;
    }


    public Human(int age, String name, String sex) {
        this.age = age;
        this.name = name;
    }


    public int getAge() {
        return age;
    }


    public void setAge(int age) {
        this.age = age;
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }


    protected void eatApple() {
        System.out.println("eat apple");
    }


    void playGame() {


    }


    @Override
    public void eat() {
        System.out.println(this.name + " performs eat");
    }


    @Override
    public String toString() {
        return "Human{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
3.1 基类或者接口


       最基本的，可以通过反射，来获取一个类的基类或者实现的接口，使用getSuperclass()或者该类的基类，使用getInterfaces()来获取该类实现的接口。直接看一下例子。


try {
    Class clz = null;
    clz = Class.forName("com.wang.demo.reflect.Human");
    if(clz != null) {
        Class superClass = clz.getSuperclass();
        System.out.println("该类的父类：");
        System.out.println(superClass.getName());


        System.out.println("该类实现的接口：");
        Class[] interfaces = clz.getInterfaces();
        for (Class clazz : interfaces) {
            System.out.println(clazz.getName());
        }
    }
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
运行结果如下图。 
图-1 获取基类和接口 
       因为在java中，类是单一继承，而接口可以实现多个，所以getSuperclass()方法返回的是个Class对象，而getInterfaces()返回的是一个Class数组。


3.2 构造函数


       获取基类和接口的方法比较单一，是直接返回了类的一些基本属性，而在获取构造函数、方法、成员变量属性时候，不同的方法是返回不同的结果。


先看获取构造函数的例子。


try {
    Class clz = null;
    clz = Class.forName("com.wang.demo.reflect.Human");


    if(clz != null) {
        int modify;
        System.out.println("该类的构造函数(getConstructors())：");


        Constructor[] cons = clz.getConstructors();
        for(Constructor constructor : cons) {
            modify = constructor.getModifiers();
            System.out.println(Modifier.toString(modify) + " " + constructor.getName());
        }


        System.out.println("\n该类的构造函数(getDeclaredConstructors())：");
        Constructor[] cons2 = clz.getDeclaredConstructors();
        for(Constructor constructor : cons2) {
            modify = constructor.getModifiers();
            System.out.println(Modifier.toString(modify) + " " + constructor.getName());
        }


        System.out.println("\n根据参数获取构造函数：");
        Constructor cons3 = clz.getDeclaredConstructor(int.class);
        if(cons3 != null) {
            System.out.println(Modifier.toString(cons3.getModifiers()) + " " + cons3.getName());
        }


        System.out.println("\n根据参数获取构造函数：");
        Constructor cons4 = clz.getConstructor(int.class);
        if(cons3 != null) {
            System.out.println(Modifier.toString(cons4.getModifiers()) + " " + cons4.getName());
        }
    }


} catch (ClassNotFoundException e) {
    e.printStackTrace();
} catch (NoSuchMethodException e) {
    e.printStackTrace();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
运行结果如下图。 
图-2 获取构造函数


       在我们定义的Human类中，有四个构造函数，两个public属性的，一个default属性，一个protected属性。


       从运行结果中可以看见，getConstuctors()得到了两个构造函数，都是public属性的，getDelaredConstructors()得到了四个构造函数，获取了Human类中的所有构造函数，跟构造函数的属性无关。getDelaredConstructor(params)根据构造函数的参数类型，获取了相匹配的构造函数，而同样的参数getConstuctor(params)抛出了异常，这是因为getConstuctor(params)根据参数去匹配所有的public属性的构造函数，而getDelaredConstructor(params)是根据参数去匹配所有的构造函数。


总体来说，四种获取构造函数的方法的区别如下：


getConstuctors()，获取的构造函数全部是public属性的。
getConstuctor(Class … params)，根据参数，从所有public属性的构造函数中获取相关构造函数
getDelaredConstructors()，获取所有的构造函数
getDelaredConstructor(Class … params)，根据参数，从所有的构造函数中获取相关构造函数
3.3 方法


在Java中，一般通过getMethods()或者getDeclaredMethod()方法来获取类中定义的方法。直接看一下这二个方法执行的例子。


例子代码：


try {
    Class clz = null;
    clz = Class.forName("com.wang.demo.reflect.Human");


    if(clz != null) {
        System.out.println("获取该类的方法(getMethods())：");
        Method[] methods1 = clz.getMethods();
        for(Method method : methods1) {
            System.out.println(Modifier.toString(method.getModifiers()) + " " +
                    method.getReturnType() + " " +
                    method.getName());
        }


        System.out.println("\n获取该类的方法(getDeclaredMethods())");
        Method[] methods2 = clz.getDeclaredMethods();
        for(Method method : methods2) {
            System.out.println(Modifier.toString(method.getModifiers()) + " " +
                    method.getReturnType() + " " +
                    method.getName());
        }
    }
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
运行结果： 
图-3 获取方法 
       这两个方法获取的结果差别还是比较大的，可以看见，getMethods()返回的都是类中public属性的方法，不止是本身声明过的public属性的方法，也包括基类中声明的public属性的方法。而getDeclaredMethods()返回的则是在类自身声明的所有方法，包括复写的方法。


       事实上，通过反射获取类中的方法还有getMethod(name，params)和getDeclaredMethod(name, params)，这两个方法主要区别在于通过参数筛选的范围不同。


四种方法的区别： 
- getMethods()返回类中所有的public属性的方法，包括从基类继承的public方法。 
- getDeclaredMethods()返回类本身声明的方法，包括复写的方法，不包括从基类继承的方法 
- getMethod(name，params)根据参数从getMethods()返回的结果中筛选 
- getDeclaredMethod(name, params)根据参数从getDeclaredMethods()返回的结果中筛选


3.4 成员变量


       成员变量获取和上面类似，主要方法有getFields()、getDeclaredFields()、getMethod(name, params)、getDeclaredMethod(name, params)四种方法。


看一下使用的例子吧。


try {
    Class clz = null;
    clz = Class.forName("com.wang.demo.reflect.Human");


    if(clz != null) {
        System.out.println("获取该类的成员变量(getFields()):");
        Field[] fields1 = clz.getFields();
        for(Field field : fields1) {
            System.out.println(Modifier.toString(field.getModifiers()) + " " + field.getName());
        }


        System.out.println("\n获取该类的成员变量(getDeclaredFields()):");
        Field[] fields2 = clz.getDeclaredFields();
        for(Field field : fields2) {
            System.out.println(Modifier.toString(field.getModifiers()) + " " + field.getName());
        }


    }
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
运行结果： 
图-4 获取成员变量


       可以看到getFields()方法只返回了public属性的成员变量，而getDeclaredFields()方法返回了所有的成员变量。至于getMethod(name, params)和getDeclaredMethod(name, params)都是在相应的范围获取成员变量。


四个方法的具体区别： 
- getFields()获取类的所有public属性的成员变量 
- getDeclaredFields()获取类的所有成员变量 
- getMethod(name, params)根据参数在getFields()获取的成员变量中进行筛选 
- getDeclaredMethod(name, params)根据参数在getDeclaredFields()获取的成员变量中进行筛选


3.5 调用&赋值


       上面说明了获取类的一些属性的方法，包括构造函数、方法和成员变量。在获取这个属性之后我们可以调用构造函数实例化对象，调用其中的方法，给成员变量赋值。


直接看代码。


try {
    Class clz = null;
    clz = Class.forName("com.wang.demo.reflect.Human");


    if(clz != null) {
        Constructor constructor = clz.getDeclaredConstructor(int.class);
        Human human = (Human)constructor.newInstance(1);
        System.out.println(human.toString());


        Method method = clz.getMethod("setName", String.class);
        method.invoke(human, "John");
        System.out.println(human.toString());


        Field field = clz.getDeclaredField("age");
        field.setAccessible(true);
        field.set(human, 12);
        System.out.println(human.toString());
    }
} catch (Exception e) {
    e.printStackTrace();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
运行结果： 
图-5 运行结果 
       代码中，我先利用反射获取构造函数Human(int age)，然后实例化一个Human对象，这个时候打印出Human信息，由于在实例化时候设置了age为1，打印出来结果name是没有值得；然后通过反射获取setName(String name)方法，并调用设置name为Jhon，输出时候可以看见age为1，name为Jhon；最后通过反射获取到Human的age成员变量，并将值设置为12，输出时候可以看见age已经改变为12了。


4. 总结
宁波抗衰老美容整形http://www.biopls.net/Anti-aging/list-9-1.shtml

       反射的使用非常简单，在一般场景下也很少用到。但是作为Java中的一个比较重要的辅助机制，还是需要了解。由于反射在获取一些属性时候异常情况比较多，一定需要慎重使用，而且反射性能比较差，在普通场景下，并不建议大量使用反射。