对Java反射机制的一点见解

发表于 | 分类于 | 阅读量 次

首先，从动态语言讲起。像Python、Ruby这种语言，只要修改了代码，修改的效果立即生效，因为这种语言是无需编译，直接执行代码的，我们称这类语言是“动态语言”。而C++、Java这种，在运行之前需要先编译，如果中途修改了代码不重新编译去执行的话就没有变化。但是，Java有一个非常突出的动态相关机制，即反射：我们可以于运行时（区别于编译时）加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class（在这之前修改这个类即时不编译都有效），获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

再通俗地说一下什么是反射？

普通的Java对象是通过new关键字把对应类的字节码文件加载到内存，然后创建该对象的。

反射是通过一个名为Class的特殊类，用Class.forName(“类名”);得到类的字节码对象，然后用newInstance()方法在虚拟机内部构造这个对象（针对无参构造函数）。

也就是说反射机制让我们可以在程序运行时动态地拿到Java类对应的字节码对象（而不是在编译的时候），然后动态的进行任何可能的操作。反射的功能主要包括：

  • 在运行时判断任意一个对象所属的类
  • 在运行时构造任意一个类的对象
  • 在运行时判断任意一个类所具有的成员变量和方法
  • 在运行时调用任意一个对象的方法（这样就可以修改这个对象的属性）
  • 生成动态代理

使用反射的主要作用是方便程序的扩展，由于其运行时动态加载的特性。

Class类

Java中只有2种东西不是面向对象的，一个基本类型，一个静态成员（方法、变量、常量）。我们提供的每一个类也是对象，一个类的类类型是java.lang.Class类的实例对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 创建类Foo的实例对象
Foo foo1 = new Foo();

// Foo这个类也是一个实例对象，Class类的实例对象
// 任何一个类都是Class的实例对象，这个实例对象有三种表达方式

// 第一种表达方式。实际上表明任何一个类都有一个隐含的静态成员变量Class
Class c1 = Foo.class;

// 第二种表达方式
Class c2 = foo1.getClass();

// 根据官网说法，c1,c2表示了Foo类的类类型(class type)
// 类也是对象，是Class类的实例对象，这个对象我们成为该类的类类型

System.out.println(c1==c2)   // true
 
// 第三种表达方式
Class c3 = Class.forName("Foo");
 
System.out.println(c1==c3)   // true

Class类的构造器是私有的，只能JVM能创建Class类的实例对象。

可以通过类类型 (上面的c1 c2 c3)创建Foo类的实例对象：

1
Foo foo = (Foo)c1.newInstance();

动态加载类

什么是动态加载？什么是静态加载？

静态加载的类在编译的时候就要提供，而动态加载的类在源程序编译时可以缺席。区分编译时和运行时。

Class.forName(“类名”) 这种方式，不仅表示了类的类类型，还代表了动态加载类。

用new这种方式静态加载方式，编译的时候，如果new的对象的那个类不存在的话，编译不通过；但是用Class.forName这种动态加载方式，没有这个类编译的时候不会报任何错，但是运行的时候会因为找不到这个类而报错。动态加载有什么好处呢？配合接口编程，可以实现一个接口对多种实现，从而可以动态地去选择完成不同的功能。因此，类动态加载对扩展功能很有用。

其实，动态类加载主要就是通过反射机制将类对象注入进去。

静态加载：

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Office_Static {  
    public static void main(String[] args) {  
        //new 创建对象，是静态加载类，在编译时刻就需要用到Word和Excel，并将其编译
        if("Word".equals(args[0])){  
            Word w = new Word();  
            w.start();  
        }  
        if("Excel".equals(args[0])){  
            Excel e = new Excel();  
            e.start();  
        }  
    }  
}

动态加载：

1
2
3
public interface OfficeAble {  
    public void start();  
}
1
2
3
4
5
public class Word implements OfficeAble {  
    public void start(){  
        System.out.println("word start");  
    }  
}
1
2
3
4
5
public class Excel implements OfficeAble {  
    public void start(){  
        System.out.println("excel start");  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class OfficeBetter {  
    public static void main(String[] args) {  
        try {  
            //动态加载类，在运行时刻才要用这个类  
            Class c = Class.forName(args[0]);//在运行配置里面输入com.imooc.加载类.Excel  
            //通过类类型，创建该类对象(先转换为Word和Excel的共同接口OfficeAble)  
            OfficeAble oa = (OfficeAble)c.newInstance();  
            oa.start();  
        } 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
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
import java.lang.reflect.Method;
import java.lang.reflect.Field;
import java.lang.reflect.Constructor;

public class ClassUtil {
    /**
     * 打印类的信息，包括类的成员函数、成员变量(只获取成员函数)
     * 
     * @param obj
     *            该对象所属类的信息
     */
    public static void printClassMethodMessage(Object obj) {
        // 要获取类的信息 首先要获取类的类类型
        Class c = obj.getClass();// 传递的是哪个子类的对象 c就是该子类的类类型
        // 获取类的名称
        System.out.println("类的名称是:" + c.getName());
        /*
         * Method类，方法对象 一个成员方法就是一个Method对象
         * getMethods()方法获取的是所有的public的函数，包括父类继承而来的
         * getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限
         */
        Method[] ms = c.getMethods();// c.getDeclaredMethods()
        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[] paramTypes = ms[i].getParameterTypes();
            for (Class class1 : paramTypes) {
                System.out.print(class1.getName() + ",");
            }
            System.out.println(")");
        }
    }

    /**
     * 获取成员变量的信息
     * 
     * @param obj
     */
    public static void printFieldMessage(Object obj) {
        Class c = obj.getClass();
        /*
         * 成员变量也是对象 java.lang.reflect.Field Field类封装了关于成员变量的操作
         * getFields()方法获取的是所有的public的成员变量的信息
         * getDeclaredFields获取的是该类自己声明的成员变量的信息
         */
        // Field[] fs = c.getFields();
        Field[] fs = c.getDeclaredFields();
        for (Field field : fs) {
            // 得到成员变量的类型的类类型
            Class fieldType = field.getType();
            String typeName = fieldType.getName();
            // 得到成员变量的名称
            String fieldName = field.getName();
            System.out.println(typeName + " " + fieldName);
        }
    }

    /**
     * 打印对象的构造函数的信息
     * 
     * @param obj
     */
    public static void printConMessage(Object obj) {
        Class c = obj.getClass();
        /*
         * 构造函数也是对象 java.lang. Constructor中封装了构造函数的信息
         * getConstructors获取所有的public的构造函数 getDeclaredConstructors得到所有的构造函数
         */
        // Constructor[] cs = c.getConstructors();
        Constructor[] cs = c.getDeclaredConstructors();
        for (Constructor constructor : cs) {
            System.out.print(constructor.getName() + "(");
            // 获取构造函数的参数列表--->得到的是参数列表的类类型
            Class[] paramTypes = constructor.getParameterTypes();
            for (Class class1 : paramTypes) {
                System.out.print(class1.getName() + ",");
            }
            System.out.println(")");
        }
    }
}

通过反射运行时动态调用对象的方法

用方法对象进行反射操作，运行时动态调用一个对象的方法：

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
import java.lang.reflect.Method;

public class MethodDemo1 {
    public static void main(String[] args) {
        // 要获取print(int ,int )方法 1.要获取一个方法就是获取类的信息，获取类的信息首先要获取类的类类型
        A a1 = new A();
        Class c = a1.getClass();
        /*
         * 2.获取方法 名称和参数列表来决定 getMethod获取的是public的方法 getDelcaredMethod自己声明的方法
         */
        try {
            // Method m = c.getMethod("print", new
            // Class[]{int.class,int.class});
            Method m = c.getMethod("print", int.class, int.class);

            // 方法的反射操作
            // a1.print(10, 20);方法的反射操作是用m对象来进行方法调用 和a1.print调用的效果完全相同
            // 方法如果没有返回值返回null,有返回值返回具体的返回值
            // Object o = m.invoke(a1,new Object[]{10,20});
            Object o = m.invoke(a1, 10, 20);
            System.out.println("==================");
            // 获取方法print(String,String)
            Method m1 = c.getMethod("print", String.class, String.class);
            // 用方法进行反射操作
            // a1.print("hello", "WORLD");
            o = m1.invoke(a1, "hello", "WORLD");
            System.out.println("===================");
            // Method m2 = c.getMethod("print", new Class[]{});
            Method m2 = c.getMethod("print");
            // m2.invoke(a1, new Object[]{});
            m2.invoke(a1);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

class A {
    public void print() {
        System.out.println("helloworld");
    }

    public void print(int a, int b) {
        System.out.println(a + b);
    }

    public void print(String a, String b) {
        System.out.println(a.toUpperCase() + "," + b.toLowerCase());
    }
}

通过反射了解Java泛型的本质

反射的操作都是编译之后的操作，反射动态加载的类是在程序运行时编译并加载的。来看看下面这个例子。

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
import java.lang.reflect.Method;
import java.util.ArrayList;

public class MethodDemo2{
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        
        ArrayList<String> list1 = new ArrayList<String>();
        list1.add("hello");
        //list1.add(20);错误的
        Class c1 = list.getClass();
        Class c2 = list1.getClass();
        System.out.println(c1 == c2);// 都是ArrayList的类类型，true
        //反射的操作都是编译之后的操作
        
        /*
         * c1==c2结果返回true说明编译之后集合的泛型是去泛型化的
         * Java中集合的泛型，是防止错误输入的，只在编译阶段有效，
         * 绕过编译就无效了
         * 验证：我们可以通过方法的反射来操作，绕过编译
         */
        try {
            Method m = c2.getMethod("add", Object.class);
            m.invoke(list1, 20);//绕过编译操作就绕过了泛型
            System.out.println(list1.size());
            System.out.println(list1);
            /*for (String string : list1) {
                System.out.println(string);
            }*///现在不能这样遍历
        } catch (Exception e) {
          e.printStackTrace();
        }
    }

}
坚持原创技术分享，您的支持将鼓励我继续创作！
显示 Gitment 评论