好得很程序员自学网

<tfoot draggable='sEl'></tfoot>

关于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的实例对象。

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

?

1

2

3

4

5

6

7

8

public class foo{

  foo(){

   //构造方法

  }

}

public foo method(){

  //...

}

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

如何表示class的实例对象?

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

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类型)创建类的实例对象。

?

1

2

3

4

5

6

7

8

9

10

//此时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类

?

1

2

3

4

5

public class office {

  public void print() {

  system.out.println( "office" );

  }

}

定义loading类

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

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类不存在,此时运行会报错。这就是为何有时候会出现编译通过,运行报错的原因。

动态加载一个好处,就是可以随时增加需要编译的类。例如把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

 

完整示例

?

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

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用于测试

?

1

2

3

4

5

public class foo{

  public void print(string name, int num) {

  system.out.println( "i am " +name+ " age " +num);

  }

}

目标:通过反射获取该方法,传入参数,执行该方法!

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

?

1

class clazz = foo. class ;

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

?

1

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

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

方法若无返回值则返回null

?

1

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

五:通过反射认识泛型

?

1

2

3

4

5

6

7

8

9

10

11

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中集合的泛型其实只是为了防止错误输入,只在编译阶段有效,绕过编译就无效。

验证

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

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

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]

成功绕过了泛型<string>的约束。

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对的支持。

原文链接:https://www.cnblogs.com/yueshutong/p/9495001.html

查看更多关于关于Java中反射机制的深入讲解的详细内容...

  阅读:47次