Java反射机制深入详解

2017-01-13 15:03:11来源:csdn作者:qq_35101189人点击

第七城市





学习Java的同学注意了!!!学习过程中遇到什么问题或者想获取学习资源的话,欢迎加入Java学习交流群,群号码:286945438我们一起学Java!



一. 概念



  反射就是把Java的各种成分映射成相应的Java类。



  Class类的构造方法是private,由JVM创建。



  反射是java语言的一个特性,它允程序在运行时(注意不是编译的时候)来进行自我检查并且对内部的成员进行操作。例如它允许一个java的类获取他所有的成员变量和方法并且显示出来。Java 的这一能力在实际应用中也许用得不是很多,但是在其它的程序设计语言中根本就不存在这一特性。例如,Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。 (来自Sun)



  JavaBean 是 reflection 的实际应用之一,它能让一些工具可视化的操作软件组件。这些工具通过 reflection 动态的载入并取得 Java 组件(类) 的属性。



  反射是从1.2就有的,后面的三大框架都会用到反射机制,涉及到类"Class",无法直接new CLass(),其对象是内存里的一份字节码.  



  Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类,注释是一种接口。每个数组属于被映射为 Class 对象的一个类,所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的 Java类型(boolean、byte、char、short、int、long、float 和 double)和关键字 void 也表示为 Class 对象。Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。 

1 Person p1 = new Person();
2 //下面的这三种方式都可以得到字节码
3 CLass c1 = Date.class();
4 p1.getClass();
5 //若存在则加载,否则新建,往往使用第三种,类的名字在写源程序时不需要知道,到运行时再传递过来
6 Class.forName("java.lang.String");


  CLass.forName()字节码已经加载到java虚拟机中,去得到字节码;java虚拟机中还没有生成字节码 用类加载器进行加载,加载的字节码缓冲到虚拟机中。 



  考虑下面这个简单的例子,让我们看看 reflection 是如何工作的。

复制代码
复制代码
1 import java.lang.reflect.*;
2
3 public class DumpMethods {
4public static void main(String args[]) {
5 try {
6Class c = Class.forName("java.util.Stack");
7
8Method m[] = c.getDeclaredMethods();
9
10for (int i = 0; i < m.length; i++)
11System.out.println(m[i].toString());
12 }
13 catch (Throwable e){
14 System.err.println(e);
15 }
16}
17 }
复制代码复制代码
1 public synchronized java.lang.Object java.util.Stack.pop()
2 public java.lang.Object java.util.Stack.push(java.lang.Object)
3 public boolean java.util.Stack.empty()
4 public synchronized java.lang.Object java.util.Stack.peek()
5 public synchronized int java.util.Stack.search(java.lang.Object)


  这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。这个程序使用 Class.forName 载入指定的类,然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。



  以下示例使用 Class 对象来显示对象的类名:

1 void printClassName(Object obj) {
2System.out.println("The class of " + obj +
3 " is " + obj.getClass().getName());
4}


  还可以使用一个类字面值(JLS Section 15.8.2)来获取指定类型(或 void)的 Class 对象。例如:

1 System.out.println("The name of class Foo is: "+Foo.class.getName());


  在没有对象实例的时候,主要有两种办法。

//获得类类型的两种方式
Class cls1 = Role.class;
Class cls2 = Class.forName("yui.Role");


  注意第二种方式中,forName中的参数一定是完整的类名(包名+类名),并且这个方法需要捕获异常。现在得到cls1就可以创建一个Role类的实例了,利用Class的newInstance方法相当于调用类的默认的构造器。

1 Object o = cls1.newInstance();
2 //创建一个实例
3 //Object o1 = new Role(); //与上面的方法等价




二. 常用方法  



  1.isPrimitive(判断是否是基本类型的字节码)

复制代码
1 public class TestReflect {
2 public static void main(String[] args) {
3 // TODO Auto-generated method stub
4 String str = "abc";
5 Class cls1 = str.getClass();
6 Class cls2 = String.class;
7 Class cls3 = null;//必须要加上null
8 try {
9 cls3 = Class.forName("java.lang.String");
10 } catch (ClassNotFoundException e) {
11 // TODO Auto-generated catch block
12 e.printStackTrace();
13 }
14 System.out.println(cls1==cls2);
15 System.out.println(cls1==cls3);
16
17 System.out.println(cls1.isPrimitive());
18 System.out.println(int.class.isPrimitive());//判定指定的 Class 对象是否表示一个基本类型。
19 System.out.println(int.class == Integer.class);
20 System.out.println(int.class == Integer.TYPE);
21 System.out.println(int[].class.isPrimitive());
22 System.out.println(int[].class.isArray());
23 }
24 }
25 /*
26* true
27 true
28 false
29 true
30 false
31 true
32 false
33 true
34
35*/
36 */
复制代码


  2.getConstructor和getConstructors()



  java中构造方法没有先后顺序,通过类型和参数个数区分。 

复制代码
1 public class TestReflect {
2 public static void main(String[] args) throws SecurityException, NoSuchMethodException {
3 // TODO Auto-generated method stub
4 String str = "abc";
5
6 System.out.println(String.class.getConstructor(StringBuffer.class));
7 }
8 }
复制代码


  3.Filed类代表某一类中的一个成员变量。

复制代码
1 import java.lang.reflect.Field;
2 public class TestReflect {
3 public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
4 ReflectPointer rp1 = new ReflectPointer(3,4);
5 Field fieldx = rp1.getClass().getField("x");//必须是x或者y
6 System.out.println(fieldx.get(rp1));
7
8 /*
9* private的成员变量必须使用getDeclaredField,并setAccessible(true),否则看得到拿不到
10*/
11 Field fieldy = rp1.getClass().getDeclaredField("y");
12 fieldy.setAccessible(true);//暴力反射
13 System.out.println(fieldy.get(rp1));
14
15 }
16 }
17
18 class ReflectPointer {
19
20 public int x = 0;
21 private int y = 0;
22
23 public ReflectPointer(int x,int y) {//alt + shift +s相当于右键source
24 super();
25 // TODO Auto-generated constructor stub
26 this.x = x;
27 this.y = y;
28 }
29 }
复制代码


  4.



三. 典型例题



  1.将所有String类型的成员变量里的b改成a。

复制代码
1 import java.lang.reflect.Field;
2 public class TestReflect {
3 public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
4 ReflectPointer rp1 = new ReflectPointer(3,4);
5 changeBtoA(rp1);
6 System.out.println(rp1);
7
8 }
9
10 private static void changeBtoA(Object obj) throws RuntimeException, Exception {
11 Field[] fields = obj.getClass().getFields();
12
13 for(Field field : fields) {
14 //if(field.getType().equals(String.class))
15 //由于字节码只有一份,用equals语义不准确
16 if(field.getType()==String.class) {
17 String oldValue = (String)field.get(obj);
18 String newValue = oldValue.replace('b', 'a');
19 field.set(obj,newValue);
20 }
21 }
22 }
23 }
24
25 class ReflectPointer {
26
27 private int x = 0;
28 public int y = 0;
29 public String str1 = "ball";
30 public String str2 = "basketball";
31 public String str3 = "itcat";
32
33 public ReflectPointer(int x,int y) {//alt + shift +s相当于右键source
34 super();
35 // TODO Auto-generated constructor stub
36 this.x = x;
37 this.y = y;
38 }
39
40 @Override
41 public String toString() {
42 return "ReflectPointer [str1=" + str1 + ", str2=" + str2 + ", str3="
43 + str3 + "]";
44 }
45 }
复制代码


  2.写一个程序根据用户提供的类名,调用该类的里的main方法。



  为什么要用反射的方式呢?

复制代码
1 import java.lang.reflect.Field;
2 import java.lang.reflect.Method;
3
4 public class TestReflect {
5 public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
6 String str = args[0];
7 /*
8* 这样会数组角标越界,因为压根没有这个字符数组
9* 需要右键在run as-configurations-arguments里输入b.Inter(完整类名)
10*
11*/
12 Method m = Class.forName(str).getMethod("main",String[].class);
13 //下面这两种方式都可以,main方法需要一个参数
14
15 m.invoke(null, new Object[]{new String[]{"111","222","333"}});
16 m.invoke(null, (Object)new String[]{"111","222","333"});//这个可以说明,数组也是Object
17 /*
18* m.invoke(null, new String[]{"111","222","333"})
19* 上面的不可以,因为java会自动拆包
20*/
21 }
22 }
23
24 class Inter {
25 public static void main(String[] args) {
26 for(Object obj : args) {
27 System.out.println(obj);
28 }
29 }
30 }
复制代码


  3.模拟 instanceof 操作符

复制代码
1 class S {
2 }
3
4 public class IsInstance {
5public static void main(String args[]) {
6 try {
7Class cls = Class.forName("S");
8boolean b1 = cls.isInstance(new Integer(37));
9System.out.println(b1);
10boolean b2 = cls.isInstance(new S());
11System.out.println(b2);
12 }
13 catch (Throwable e) {
14System.err.println(e);
15 }
16}
17 }
复制代码


  在这个例子中创建了一个S 类的 Class 对象,然后检查一些对象是否是S的实例。Integer(37) 不是,但 new S()是。



四. Method类



  代表类(不是对象)中的某一方法。

复制代码
1 import java.lang.reflect.Field;
2 import java.lang.reflect.Method;
3 /*
4* 人在黑板上画圆,涉及三个对象,画圆需要圆心和半径,但是是私有的,画圆的方法
5* 分配给人不合适。
6*
7* 司机踩刹车,司机只是给列车发出指令,刹车的动作还需要列车去完成。
8*
9* 面试经常考面向对象的设计,比如人关门,人只是去推门。
10*
11* 这就是专家模式:谁拥有数据,谁就是专家,方法就分配给谁
12*/
13 public class TestReflect {
14 public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
15 String str = "shfsfs";
16 //包开头是com表示是sun内部用的,java打头的才是用户的
17 Method mtCharAt = String.class.getMethod("charAt", int.class);
18 Object ch = mtCharAt.invoke(str,1);//若第一个参数是null,则肯定是静态方法
19 System.out.println(ch);
20
21 System.out.println(mtCharAt.invoke(str, new Object[]{2}));//1.4语法
22
23 }
24
25 }
复制代码




五. 数组的反射



  Array工具类用于完成数组的反射操作。



  同类型同纬度有相同的字节码。



  int.class和Integer.class不是同一份字节码,Integer.TYPE,TYPE代表包装类对应的基本类的字节码 int.class==Integer.TYPE

复制代码
1 import java.util.Arrays;
2
3 /*
4* 从这个例子看出即便字节码相同但是对象也不一定相同,根本不是一回事
5*
6*/
7 public class TestReflect {
8 public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
9 int[] a = new int[3];
10 int[] b = new int[]{4,5,5};//直接赋值后不可以指定长度,否则CE
11 int[][] c = new int[3][2];
12 String[] d = new String[]{"jjj","kkkk"};
13 System.out.println(a==b);//false
14 System.out.println(a.getClass()==b.getClass());//true
15 //System.out.println(a.getClass()==d.getClass());//比较字节码a和cd也没法比
16 System.out.println(a.getClass());//输出class [I
17 System.out.println(a.getClass().getName());//输出[I,中括号表示数组,I表示整数
18
19 System.out.println(a.getClass().getSuperclass());//输出class java.lang.Object
20 System.out.println(d.getClass().getSuperclass());//输出class java.lang.Object
21
22 //由于父类都是Object,下面都是可以的
23 Object obj1 = a;//不可是Object[]
24 Object obj2 = b;
25 Object[] obj3 = c;//基本类型的一位数组只可以当做Object,非得还可以当做Object[]
26 Object obj4 = d;
27
28 //注意asList处理int[]和String[]的区别
29 System.out.println(Arrays.asList(b));//1.4没有可变参数,使用的是数组,[[I@1bc4459]
30 System.out.println(Arrays.asList(d));//[jjj, kkkk]
31
32 }
33 }
复制代码


六. 结束语  以上就是反射机制的简单的使用,显然学过spring的朋友一定明白了,为什么可以通过配置文件就可以让我们获得指定的方法和变量,在我们创建对象的时候都是通过传进string实现的,就好像你需要什么,我们去为你生产,还有我们一直在用Object,这就说明java语言的动态特性,依赖性大大的降低了。










学习Java的同学注意了!!!学习过程中遇到什么问题或者想获取学习资源的话,欢迎加入Java学习交流群,群号码:286945438我们一起学Java!


第七城市

最新文章

123

最新摄影

微信扫一扫

第七城市微信公众平台