构造函数、成员变量、成员方法、静态方法、数组的反射应用

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/xiaoma_fan/article/details/41924863

1、     反射就是通过Class类提供的方法获取所有class类的构造函数(Constructor)、成员变量(Field)、成员方法(Method)、静态方法等;

2、Class类和class类的区别:描述所有人的类是Person类(class类),描述所有java类的的类是Class类Person类的实例是张三、李四; Class类的实例是各个类在内存中的字节码; 每个类在内存中的字节码是不同的,若每个类空间都用一个个对象来表示, 那么这些对象就具有相同的类型,那么这个类型就是Class

3、获取Sting字节码对应的实例对象(Class类型)的三种方法如下:

public class ReflectDemo {

	public static void sop(Object obj) {
		System.out.println(obj);
	}

	public static void main(String[] args) throws Exception {
		String s = "abcd";
		// 三种获取String字节码对应的实例对象(Class类型),
		//1、实例对象的getClass()方法获取
		Class<? extends String> cla = s.getClass();
		// 2、类名.class获取
		Class<String> clb = String.class;
		// 3、Class.forName("类名")方法获取
		Class<?> clc = Class.forName("java.lang.String");
		sop(cla == clb);
		sop(clb == clc);
		sop(cla);
		sop(clb);
		sop(clc);
	}
}
运行结果是:

true
true
class java.lang.String
class java.lang.String
class java.lang.String
通过结果知道三个获取的字节码是一致的,都是【class java.lang.String
4、通过反射的原理写出构造方法

// 创造String实例的普通方法
		sop(new String(new StringBuffer("abc")));
		/*
		 * 创造String实例的反射方法,首先获取到String字节码的构造方法StringBuffer.class,
		 * 调用获得的构造方法时要用到相同类型的实例对象, 编译时没有使用cons后面的语句, 所以编译时若没有指定(String)则报错
		 * 
		 * Constructor类代表构造函数的类,通过字节码可以获取到任意一个类的构造函数
		 */
		// 通过类名.class获得的String字节码
		Constructor cons = String.class.getConstructor(StringBuffer.class);
		String str = (String) cons.newInstance(new StringBuffer("abc"));
		sop(str);
		// 通过Class.forName("类名")获得类名String的字节码
		Constructor cons1 = Class.forName("java.lang.String").getConstructor(
				StringBuffer.class);
		String str1 = (String) cons1.newInstance(new StringBuffer("bcd"));
		sop(str1);
		// 通过实例对象的获得
		String s1 = new String();
		Constructor cons2 = s1.getClass().getConstructor(StringBuffer.class);
		String str2 = (String) cons.newInstance(new StringBuffer("efg"));
		sop(str2);

		// 该方法获得是获得String类的无参构造函数
		String str3 = (String) Class.forName("java.lang.String").newInstance();
结果是:

abc
abc
bcd
efg
通过结果知道通过获取的String字节码调用Constructor类获取String类的构造方法结果是一致的


5、成员常量和成员方法的反射应用如下:

成员常量的类是Field类,成员方法的类是Method类

		/*
		 * Field类代表成员变量的类,通过二阶码可以获取任何类内的成员变量
		 */
		FieldClass fic = new FieldClass(4, 8);
		// public修饰的常量y,通过Field参数获取
		Field fa = fic.getClass().getField("y");
		sop(fa.get(fic));
		// private修饰的常量x,通过Field参数获取
		Field fb = fic.getClass().getDeclaredField("x");
		fb.setAccessible(true);
		sop(fb.get(fic));

		/*
		 * Method类代表成员方法的类,通过二节码可以获取任何类内的成员方法
		 */
		String st = "5678";
		Method mt = Class.forName("java.lang.String").getMethod("charAt",
				int.class);
		sop(mt.invoke(st, 2));
		//静态成员方法用反射的类调用,需要在invoke(null,)的第一个参数为空
		Method mta = Class.forName("java.lang.String").getMethod("valueOf",
				int.class);
		sop("静态成员方法:" + mta.invoke(null, 2));

6、反射调用另外一个类的main函数

import java.lang.reflect.Method;

public class ReflectMain {

	public static void main(String[] args) throws Exception {
		//调用主函数的参数,设置主函数的参数为newStudy.template(通过F2查看template的路径)
		String startClassName = args[0];
		Method mainMethod = Class.forName(startClassName).getMethod("main",
				String[].class);
		/*
		 * jdk1.5中是可变参数形式Object invoke(Object obj, Object...args).
		 * jdk1.4中是参数数组形式Object invoke(Object obj, Object[] obj).
		 * jdk1.5为了兼容jdk1.4,invoke()方法要接收到一个参数数组时,也会将数组进行拆分,当成方法的多个参数
		 */
		mainMethod.invoke(null, new Object[] { new String[] { "1", "2", "3" } });
		mainMethod.invoke(null, (Object) new String[] { "a", "b", "c" });
	}
}

class template {
	public static void main(String[] args) {
		for (String arg : args) {
			System.out.println(arg);
		}
	}
}
7、int[]等基本数据类型数组和String[]等引用数据类型数据在反射处理上是有些不同的,int[]等基本数据类型是按照一个整体处理,String[]等引用类型则自动进行拆分

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayReflectDemo {

	public static void main(String[] args) {
		int[] a = new int[] { 1, 3, 5 };
		int[] b = new int[2];
		int[][] c = new int[2][];
		String[] s = new String[] { "sf", "wfw" };
		sop(a.getClass() == b.getClass());
		// 打印的[I 代表的是int类型的数组
		sop(a.getClass().getName());
		sop(s.getClass().getName());
		/*
		 * Incompatible operand types Class<capture#4-of ? extends int[]> and
		 * Class<capture#5-of ? extends int[][]> 下面两个都是互相不兼容的操作数据类型,不允许编译通过
		 */
		/*
		 * sop(a.getClass() == c.getClass()); sop(a.getClass() == s.getClass());
		 */
		sop(a.getClass().getSuperclass().getName());
		sop(s.getClass().getSuperclass().getName());

		Object aobj = a;
		Object bobj = b;
		Object cobj = c;
		Object sobj = s;
		/*
		 * 下面三个的打印结果是[[I@15db9742] 
		 * [I@15db9742 
		 * [[I@15db9742] 
		 * [I代表是整型的数组,[]代表的是集合
		 */
		sop("********");
		sop(Arrays.asList(a));
		//如果sop方法判断是否是数组,则可以逐个打印出来
		sop(a);
		sop(Arrays.asList(aobj));

		/*
		 * 下面三个打印的结果是:[sf, wfw] 
		 * [Ljava.lang.String;@6d06d69c
		 * [[Ljava.lang.String;@6d06d69c] 
		 * 基本数据类型的数组转换成集合后不能打印出来集合内的元素,
		 * String类型的可以转换成集合后且可以打印出集合内的元素
		 */
		sop("********");
		sop(Arrays.asList(s));
		//如果sop方法判断是否是数组,则可以逐个打印出来
		sop(s);
		sop(Arrays.asList(sobj));

	}
/*	private static void sop(Object obj){
		System.out.println(obj);
	}*/

	private static void sop(Object obj) {
		Class<? extends Object> a = obj.getClass();
		if(a.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);
		}
	}

}

总结:

反射原理就是通过Class类型获取字节码内的构造方法、成员常量、成员方法赋予一个类(Constructor、Field、Method),再通过对应的类的方法获取java类的数据











阅读更多

没有更多推荐了,返回首页