黑马程序员-------（高新技术）反射

最新推荐文章于 2019-10-21 22:36:54 发布

原创最新推荐文章于 2019-10-21 22:36:54 发布 · 587 阅读

0 ·

CC 4.0 BY-SA版权

本文深入讲解Java反射机制的基础知识及应用场景，包括Class类的作用、如何获取Class实例、反射中的Constructor、Field、Method类的使用方法，并通过实例演示了反射在创建对象、调用方法等方面的应用。

-------------java培训、android培训、java博客、java学习型技术博客、期待与您交流！ --------------

反射的基石Class类

对比提问： Person类代表人，它的实例对象就是张三，李四这样一个个具体的人， Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。对比提问：众多的人用一个什么类表示？众多的Java类用一个什么类表示？
人Person
Java类Class
Class类代表Java类，它的各个实例对象又分别对应什么呢？
对应各个类在内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等等。
一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型是什么呢？
如何得到各个字节码对应的实例对象（ Class类型）
类名.class，例如，System.class
对象.getClass()，例如，new Date().getClass()
Class.forName("类名")，例如，Class.forName("java.util.Date");
九个预定义Class实例对象：
参看Class.isPrimitive方法的帮助
Int.class == Integer.TYPE
数组类型的Class实例对象
Class.isArray()
总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[]，void…

反射

反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。
一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。

//String是一个类，不是（原始）基本类型
		String str1 = "abc";
		String str2 = "zzz";
		Class cls1 = str1.getClass();
		Class cls4 = str2.getClass();
		Class cls2 = String.class;
		Class cls3 = Class.forName("java.lang.String");
		System.out.println(cls1==cls2);
		System.out.println(cls1==cls3);
		System.out.println(cls1==cls4);
		System.out.println("-----------------------------------------------");
		//是否为原始（基本）类型
		System.out.println("void:   "+void.class.isPrimitive());
		System.out.println("int:   "+int.class.isPrimitive());
		System.out.println("String:   "+String.class.isPrimitive());
		System.out.println("cls1:   "+cls1.isPrimitive());
		System.out.println("--------------------------------------------");
		System.out.print("int.class==Integer.class:   ");
		System.out.println(int.class==Integer.class);
		//Integer中定义一个常量TYPE，代表包装类所包装的基本类型的字节码
		System.out.print("int.class==Integer.TYPE:   ");
		System.out.println(int.class==Integer.TYPE);
		//数组是否为原始（基本）类型
		System.out.println(int[].class.isPrimitive());
		//数组是否为isArray()
		System.out.println(int[].class.isArray());

Constructor类

Constructor类代表某个类中的一个构造方法
得到某个类所有的构造方法：
例子：Constructor [] constructors= Class.forName("java.lang.String").getConstructors();
得到某一个构造方法：
例子： Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);
//获得方法时要用到类型
创建实例对象：
通常方式：String str = new String(new StringBuffer("abc"));
反射方式： String str = (String)constructor.newInstance(new StringBuffer("abc"));
//调用获得的方法时要用到上面相同类型的实例对象
Class.newInstance()方法：
例子：String obj = (String)Class.forName("java.lang.String").newInstance();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。

System.out.println("--------Constructor---------");
		//得到String类中参数为StringBuffer的构造方法
		//new String(new StringBuffer("abc"));
		//第一个StringBuffer.class 表示选择哪个构造方法
		Constructor<String> constructor1 = String.class.getConstructor(StringBuffer.class/*,StringBuilder.class*/);
		//第二个StringBuffer 表示创建对象时，需要传入的参数
		String con1_str = constructor1.newInstance(new StringBuffer("abc"));
		/*该局编译时不报错，但是运行时报错，原因是对应的构造方法传入参数不匹配
		String con1_str2 = construct你 or1.newInstance("abc");*/
		System.out.println(con1_str);
		System.out.println(con1_str.charAt(2));

Field类

Field类代表某个类中的一个成员变量
演示用eclipse自动生成Java类的构造方法
问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？所以字段fieldX 代表的是x的定义，而不是具体的x变量。
示例代码：
ReflectPoint point = new ReflectPoint(1,7);
Field y = Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");
System.out.println(y.get(point));
//Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getField("x");
Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x");
x.setAccessible(true);
System.out.println(x.get(point));
作业：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。

System.out.println("--------Field---------");
		//【x】是private  【y】是public   【z】是默认   -----getField("y"); 只能获取那些可见的
		ReflectPoint pt1 = new ReflectPoint(1,2,3);
		ReflectPoint pt2 = new ReflectPoint(4,5,6);
		//得到对应【y】变量名的字段,fieldy不代表pt1、pt2某个具体的值，
		//fieldy的值是多少？等于5？错！fieldy不是对象身上的变量，而是类上的。而是要用fieldy去取某个对象上对应的值
		Field fieldy = pt2.getClass().getField("y");
		//fieldy从哪个对象【pt1】上取对应【y】的值,   其中【y】是public
		System.out.println("pt1____y:   "+fieldy.get(pt1));
		System.out.println("pt2____y:   "+fieldy.get(pt2));	
		//【x】是private  【y】是public   【z】是默认  -----getDeclaredField("y"); 
		//凡是有声明的，都能通过getDeclaredField获取，但是要设为可见setAccessible(true);
		Field fieldx = pt2.getClass().getDeclaredField("x");
		//暴力反射，设置为可见的
		fieldx.setAccessible(true);
		System.out.println("pt1____x:   "+fieldx.get(pt1));
		System.out.println("pt2____x:   "+fieldx.get(pt2));
		//【z】是默认  -----getDeclaredField("y"); 
		Field fieldz = pt1.getClass().getDeclaredField("z");
		//暴力反射，设置为可见的
		fieldz.setAccessible(true);
		System.out.println("pt1____z:   "+fieldz.get(pt1));
		System.out.println("pt2____z:   "+fieldz.get(pt2));

System.out.println("-------------作业：Field类所有String变量都   b变a------------");	
		changStringValue(pt1);
		System.out.println(pt1);
		System.out.println(pt2);
		changStringValue(ReflectPoint.class);
		System.out.println(ReflectPoint.class);

Method类

Method类代表某个类中的一个成员方法
得到类中的某一个方法：
例子： Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);
调用方法：
通常方式：System.out.println(str.charAt(1));
反射方式： System.out.println(charAt.invoke(str, 1));
如果传递给Method对象的invoke()方法的第一个参数为null，这有着什么样的意义呢？说明该Method对象对应的是一个静态方法！
jdk1.4和jdk1.5的invoke方法的区别：
Jdk1.5：public Object invoke(Object obj,Object... args)
Jdk1.4：public Object invoke(Object obj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。

System.out.println("---------Method--------");
		//getMethod(p1,p2)要传入3个参数：p1代表方法名称，p2代表区别具体的方法（有多个重载的方法）
		//例如：str1.charAt(1);
		str1 = "abc";
		Method methodCharAt = String.class.getMethod("charAt", int.class);
		//methodCharAt.invoke():::拿该方法，调用方法作用于str1对象
		System.out.println(methodCharAt.invoke(str1, 1));	//JDK1.5之后的写法（可变参数）
		System.out.println(methodCharAt.invoke(str1, new Object[]{1}));	//JDK1.4的写法
		
		//如果作用对象是【null】，那么说明该方法是静态方法
		//System.out.println(methodCharAt.invoke(null, 1));

用反射方式执行某个类中的main方法

目标：
写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。用普通方式调完后，大家要明白为什么要用反射方式去调啊？
问题：
启动Java程序的main方法的参数是一个字符串数组，即public static void main(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,new String[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。
解决办法：
mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});
mainMethod.invoke(null,(Object)new String[]{"xxx"}); ，编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了

System.out.println("-----------用反射方式执行某个类中的main方法----------");
		TestArguments.main(new String[]{"1111","222","333"});
		//即将被执行的类的名称
		String startingClassName = args[0];
		Method mainMethod = Class.forName(startingClassName).getMethod("main", String[].class);
		//main()是静态方法,所以传null
		//又因为Java不把new String[]{"1111","222","333"}看作一个元素，而是开看内容所以有3个元素
		//所以这里做特殊处理：再次封装成new Object[]{}的一个数组
		mainMethod.invoke(null, new Object[]{new String[]{"1111","222","333"}});
		//李老师的处理方式：
		System.out.println("李老师的处理方式：");
		mainMethod.invoke(null, (Object)new String[]{"1111","222","333"});

class TestArguments{
	public static void main(String[] args){
		for(String arg:args)
			System.out.println(arg);
	}
}

数组的反射

具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
Arrays.asList()方法处理int[]和String[]时的差异。
Array工具类用于完成对数组的反射操作。
思考题：怎么得到数组中的元素类型？

System.out.println("-----------数组的反射----------");
		int [] a1 = new int[]{1,2,3};		
		int [] a5 ={100,212,323};
		int [] a2 = new int[4];
		int [][] a3 = new int[2][3];
		String [] a4 = new String[]{"a","b","c"};
		System.out.println(a1.getClass()==a2.getClass());
		//System.out.println(a1==a3);	//不同维数的数组比较，在编译时就报错了
		//System.out.println(a1==a4);		//不同类型的数组比较，在编译时就报错了
		//System.out.println(a1.getClass()==a3.getClass());	//不同维数的数组比较，在编译时就报错了
		//System.out.println(a1.getClass()==a4.getClass());	//不同类型的数组比较，在编译时就报错了
		System.out.println(a1.getClass()==a5.getClass());
		System.out.println(a1.getClass().getName());
		System.out.println(a2.getClass().getName());
		System.out.println(a3.getClass().getName());
		System.out.println(a4.getClass().getName());
		System.out.println(a5.getClass().getName());
		System.out.println(a1.getClass().getSuperclass().getName());
		System.out.println(a2.getClass().getSuperclass().getName());
		System.out.println(a3.getClass().getSuperclass().getName());
		System.out.println(a4.getClass().getSuperclass().getName());
		System.out.println(a5.getClass().getSuperclass().getName());
		//打印结果发现，a1、a4的父类都是Object。
		Object aObj1 = a1;
		Object aObj2 = a4;
		//Object [] aObj3 = a1;	//装的是int ，但是int不是Object的，所以编译错误
		Object [] aObj4 = a3;	//装的是一维数组并且是Object，所以通过
		Object [] aObj5 = a4;	//装的是String并且是Object，所以通过  
		
		//想要遍历数组中的所有元素，但是输出*&……*&……*
		System.out.println("直接打印");
		System.out.println(a1);
		System.out.println(a4);
		//用Arrays工具类快速遍历数组中的元素
		System.out.println("工具类打印");
		System.out.println(Arrays.toString(a4));
		System.out.println(Arrays.toString(a5));
		System.out.println("Arrays.asList()方法处理int[]和String[]时的差异。");
		System.out.println("原因：基本类型的一维数组可以被当作Object类型使用，\n" +
				"不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，\n" +
				"又可以当做Object[]类型使用。");
		System.out.println(Arrays.asList(a4));
		//原因是，int没有当做Object处理
		System.out.println(Arrays.asList(a5));
		System.out.println("-------------反射数组的应用-------------");
		Object obj = null;
		
		printObject(a1);
		printObject("xyz");

private static void printObject(Object obj) {
		Class clazz = obj.getClass();
		if(clazz.isArray()){
			int len = Array.getLength(obj);
			for(int i = 0 ;i<len;i++){
				System.out.println(Array.get(obj, i));
			}
		}else{
			System.out.println(obj);
		}
		
	}

private static void changStringValue(Object obj) throws Exception{
		Field[] fields = obj.getClass().getFields();
		//遍历
		for(Field field:fields){
			//field.getType()得到字段自己的类型【int、string、long】
			//虽然用equals()也可以，但是用 == 更恰当，因为都是同一份字节码
			if(field.getType() == String.class){
				String oldValue = (String) field.get(obj);
				String newValue = oldValue.replace('b', 'a');
				//将对象的值重新赋值
				field.set(obj, newValue);
			}
		}		
	}

运行结果

true
true
true
-----------------------------------------------
void:   true
int:   true
String:   false
cls1:   false
--------------------------------------------
int.class==Integer.class:   false
int.class==Integer.TYPE:   true
false
true
--------Constructor---------
abc
c
--------Field---------
pt1____y:   2
pt2____y:   5
pt1____x:   1
pt2____x:   4
pt1____z:   3
pt2____z:   6
-------------作业：Field类所有String变量都   b变a------------
ReflectPoint [str1=aall, str2=aasketaall, str3=itcast]
ReflectPoint [str1=ball, str2=basketball, str3=itcast]
class cn.itcast.day1.ReflectPoint
---------Method--------
b
b
-----------用反射方式执行某个类中的main方法----------
1111
222
333
1111
222
333
李老师的处理方式：
1111
222
333
-----------数组的反射----------
true
true
[I
[I
[[I
[Ljava.lang.String;
[I
java.lang.Object
java.lang.Object
java.lang.Object
java.lang.Object
java.lang.Object
直接打印
[I@c21495
[Ljava.lang.String;@1d5550d
工具类打印
[a, b, c]
[100, 212, 323]
Arrays.asList()方法处理int[]和String[]时的差异。
原因：基本类型的一维数组可以被当作Object类型使用，
不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，
又可以当做Object[]类型使用。
[a, b, c]
[[I@15f5897]
-------------反射数组的应用-------------
1
2
3
xyz

-------------java培训、android培训、java博客、java学习型技术博客、期待与您交流！ --------------