Java反射基础

每个类都有一个 Class 对象,包含了与类有关的信息。当编译一个新类时,会产生一个同名的 .class 文件,该文件内容保存着 Class 对象。

类加载相当于 Class 对象的加载,类在第一次使用时才动态加载到 JVM 中。也可以使用 Class.forName("com.mysql.jdbc.Driver") 这种方式来控制类的加载,该方法会返回一个 Class 对象。

反射可以提供运行时的类信息,并且这个类可以在运行时才加载进来,甚至在编译时期该类的 .class 不存在也可以加载进来。

Class 和 java.lang.reflect 一起对反射提供了支持,java.lang.reflect 类库主要包含了以下三个类:

  • Field :可以使用 get() 和 set() 方法读取和修改 Field 对象关联的字段;
  • Method :可以使用 invoke() 方法调用与 Method 对象关联的方法;
  • Constructor :可以用 Constructor 创建新的对象。

反射的优点:

  • 可扩展性 :应用程序可以利用全限定名创建可扩展对象的实例,来使用来自外部的用户自定义类。
  • 类浏览器和可视化开发环境 :一个类浏览器需要可以枚举类的成员。可视化开发环境(如 IDE)可以从利用反射中可用的类型信息中受益,以帮助程序员编写正确的代码。
  • 调试器和测试工具 : 调试器需要能够检查一个类里的私有成员。测试工具可以利用反射来自动地调用类里定义的可被发现的 API 定义,以确保一组测试中有较高的代码覆盖率。

反射的缺点:

尽管反射非常强大,但也不能滥用。如果一个功能可以不用反射完成,那么最好就不用。在我们使用反射技术时,下面几条内容应该牢记于心。

  • 性能开销 :反射涉及了动态类型的解析,所以 JVM 无法对这些代码进行优化。因此,反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。
  • 安全限制 :使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行,如 Applet,那么这就是个问题了。
  • 内部暴露 :由于反射允许代码执行一些在正常情况下不被允许的操作(比如访问私有的属性和方法),所以使用反射可能会导致意料之外的副作用,这可能导致代码功能失调并破坏可移植性。反射代码破坏了抽象性,因此当平台发生改变的时候,代码的行为就有可能也随着变化。

Class类的使用:

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
public class ClassDemo
{

public static void main(String[] args)
{
Test t1 = new Test();
Class c1 = Test.class;
Class c2 = t1.getClass();
System.out.println(c1 == c2); // 证明类类型也是引用

Class c3 = null;
try
{
c3 = Class.forName("com.reflect.Test"); // 动态加载Test类
} catch (ClassNotFoundException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(c2 == c3);
}

}

class Test{}

打印结果为:true true

获取方法信息:

  • getDeclaredMethods 方法返回类或接口声明的所有方法,包括公共、保护、默认(包)访问和私有方法,但不包括继承的方法。
  • getMethods 方法返回某个类的所有公用(public)方法,包括其继承类的公用方法。
  • getMethod 方法返回一个特定的方法,其中第一个参数为方法名称,后面的参数为方法的参数对应Class的对象。
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
public class ClassUtil
{

public static void printClassMeeeage(Object obj)
{
// 获取类的信息 首先获得类的类类型
Class c = obj.getClass();
// 获取类的名称
System.out.println("类的名称:" + c.getName());
/*
* Method类,方法对象
* 一个成员方法就是一个Method对象
* getMethod()方法获取的是所有的public函数,包括父类继承而来
*
*/
Method[] ms = c.getMethods(); // c.getDeclaredMethod()
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(")");
}
}
}

获取成员变量信息:

  • getFiled:访问公有的成员变量
  • getDeclaredField:所有已声明的成员变量,但不能得到其父类的成员变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void printFieldMessage(Object obj)
{
Class c = obj.getClass();
Field[] fs = c.getDeclaredFields();
for (Field field : fs)
{
// 获取成员变量类型的类类型
Class fieldType = field.getType();
String typeName = fieldType.getName();
// 获取成员变量的名称
String fieldName = field.getName();
System.out.println(fieldName + " " + typeName);
}
}

获取构造方法信息

* 构造方法也是对象

* java.lang.reflect.Constructor

* Constructor封装了关于构造方法的操作

* getConstructor获得该类声明额构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void printConMessage(Object obj)
{
Class c = obj.getClass();
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(")");
}
}

调用方法

当我们从类中获取了一个方法后,我们就可以用 invoke() 方法来调用这个方法。invoke 方法的原型为:

1
2
3
public Object invoke(Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException

下面是一个实例:

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
public class test1 {

public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class<?> klass = methodClass.class;
//创建methodClass的实例
Object obj = klass.newInstance();
//获取methodClass类的add方法
Method method = klass.getMethod("add",int.class,int.class);
//调用method对应的方法 => add(1,4)
Object result = method.invoke(obj,1,4);
System.out.println(result);
}

}

class methodClass {

public final int fuck = 3;
public int add(int a,int b) {
return a+b;
}
public int sub(int a,int b) {
return a+b;
}
}

推荐文章:深入解析 Java 反射(1)- 基础