java高新技术——反射

最新推荐文章于 2017-07-30 17:34:00 发布

原创最新推荐文章于 2017-07-30 17:34:00 发布 · 693 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #反射

Java 专栏收录该内容

12 篇文章

订阅专栏

本文深入探讨Java反射机制的概念、原理及其实现方法，包括Class类、Constructor、Field、Method类的应用，以及如何利用反射执行类的main方法、数组反射、hashCode与HashSet关系等内容。重点介绍了反射在实现框架功能、简化复杂程序设计过程中的重要作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

个人小结：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。反射机制是构建框架技术的基础，必须重点掌握，这对以后学习框架技术都会有很大的帮助。

一、反射的基石->Class类

1、Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。

2、对比提问：众多的人用一个什么类表示？众多的Java类用一个什么类表示？
人->Person

java类->Class

3、对比提问：Person类代表人，他的实例对象就是张三，李四这样一个个具体的人，
Class类代表java类，他的各个实例对象又分别对应什么呢？
对应各个类在内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等等。一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以他们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型就是Class类型。

4、如何得到各个字节码对应的实例对象（Class类型）
类名.Class,例如：System.class
对象.getClass(),例如：new Date().getClass()
Class.forName("类名")，例如：Class.forName("java.util.Date");

5、九个预定义的Class实例对象：
这九个分别表示八个基本数据类型byte、short、int、long、float、double、char、boolean和 void。
参看Class.isPrimitive方法的帮助
(判定指定的 Class 对象是否表示一个基本类型。)

数组类型的Class实例对象，用的是Class.isArray()判断是不是。
总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[],void

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。所以不能通过new来创建对象。

示例：

class  Reflect1
{
	public static void main(String[] args) throws Exception
	{
		String str1 = "abc";
		String str2 = "dbc";

		Class cls1 = str1.getClass();
		Class cls4 = str2.getClass();

		Class cls2 = String.class;
		Class cls3 = Class.forName("java.lang.String");
		
		System.out.println(cls2);		
		System.out.println(cls1 == cls3);	
		System.out.println(cls1 == cls4);

		System.out.println(cls1.isPrimitive());//String不是基本类型
		System.out.println(int.class.isPrimitive());
		System.out.println(int.class == Integer.class);	
		System.out.println(int.class == Integer.TYPE);// true
		//Ingeger.TYPE是一个常量，表示基本类型 int 的 Class 实例,也就表示对应基本类型的字节码。
	
		System.out.println(int[].class.isPrimitive());// false
		System.out.println(int[].class.isArray());// true

	}
}

运行结果：

二、反射的定义

反射就是把Java类中的各种成分映射成相应的Java类。例如，一个Java类用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。

表示Java类的Class类显然要提供一系列的方法，来获取其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示的，他们是Field、Method、Constructor、Package等等。

一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用？怎么用呢？这正是学习和应用反射的要点。

三、Constructor类

1、Constructor类代表某个类中的一个构造方法

2、得到某个类所有的构造方法：
例子：Constructor[] constructors = Class.forName("java.lang.String").getConstructors();

2、得到某一个构造方法：
例:Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);
获得方法时要用到类型。

3、创建实例对象：
通常方式：String str = new String(new StringBuffer("abc"));
反射方式：String str = (String)constructor.newInstance(new StringBuffer("abc"));
调用获得的方法时，要用到上面相同类型的实例对象。

4、Class.newInstance()方法：
例子：String obj = (String)Class.forName("java.lang.String").newInstance();
该方法内部得到默认的构造方法，然后用该构造方法创建实例对象。
该方法内部的具体代码是怎样写的呢？
用到了缓存机制来保持默认构造方法的实例对象。

2、一个类有多个构造方法，用什么方式可以区分清楚想得到其中的哪个方法呢？根据参数的个数和类型。例:Class.getMethod(name,Class...args)中的args参数就代表所要获取的那个方法的各个参数的类型的列表。

重点：参数类型用什么方式表示？用Class实例对象。例如：
int.class, (int[]).class
int[] ints = new int[];
ints.getClass();

Constructor对象代表一个构造方法，Constructor对象上有这些方法：
得到名字，得到所属于的类，产生实例对象。

3、讲解创建实例对象时，先应该举例说说通常情况下是怎么样做的：
String str = new String(new StringBuffer("abc"));

示例：

import java.lang.reflect.*;
class  Reflect2
{
	public static void main(String[] args) throws Exception
	{
		//new String(new StringBuffer("abc"));
		Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
		String str2 = (String)constructor1.newInstance(new StringBuffer("abc"));
		//这里的（String）一定要有，因为如果没有，在编译时，jvm并不知道是哪个类的Constructor,就报错

		System.out.println(str2.charAt(2));
	}
}

运行结果：

四、Field类

Field类代表某个类中的一个成员变量
问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？
类只有一个，而这个类的实例对象有多个，如果是与对象关联，那关联的是哪个对象呢？
所以字段fieldX 代表的是x 的定义，而不是具体的x 变量。

示例代码:

ReflectPoint pt1 = 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");
x.setAccessible(true);
System.out.println(x.get(point));

作业：
将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"

import java.lang.reflect.*;
class ReflectField 
{
	public static void main(String[] args) throws Exception
	{
		ReflectPoint pt1 = new ReflectPoint(3,5);
		Field fieldY= pt1.getClass().getField("y");
		//fieldY 的值是5？错！ 
		//fieldY不是对象身上的变量，而是类上的，要用它去取某个对象上
		//对应的值。所以要用get方法把 对象 当参数传递进去。
		System.out.println(fieldY.get(pt1));

		Field fieldX= pt1.getClass().getDeclaredField("x");
		fieldX.setAccessible(true);//暴力反射，用来获取私有变量的值
		System.out.println(fieldX.get(pt1));

		changeStringValue(pt1);
		System.out.println(pt1);

	}

	private static void changeStringValue(Object obj) throws Exception
	{
		Field[] fields = obj.getClass().getFields();
		for (Field field : fields )
		{
			//这里应该用==号，而非equals,因为是同一份字节码
			if (field.getType() == String.class)
			{
				String oldValue = (String)field.get(obj);
				String newValue = oldValue.replace('b','a');
				field.set(obj,newValue);
			}
		}
	}
}

运行结果：

五、Method 类

1、Method类代表某个类中的一个成员方法

2、得到类中的某个方法；
例子：Method charAt = Class.forName("java.lang.String").getMethod("charAt",int.class);

3、调用方法
通常方式：System.out.println(str.charAt(1));
反射方式：System.out.println(charAt.invoke(str,1));
如果传递给Method对象的invoke()方法的一个参数为null, 说明该Method对象对应的是一个静态方法！

4、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方法时。

通过思考和推理来学习反射中的API。

例如，Class.getMethod方法用于得到一个方法，该方法要接收什么参数呢？显然要一个方法名。

而一个同名的方法有多个重载形式，用什么方式可以区分清楚想得到重载方法列表中的哪个方法呢？

根据参数的个数和类型，例如，Class.getMethod(name,Class...args);
args参数就代表所要获取的哪个方法的各个参数的类型的列表。
强调：参数类型是用Class对象来表示的！

插入知识：面向对象的理解

人在黑板上画圆，需要圆心和半径，所以画圆的方法只有分配给圆才是合适的。
列车司机把列车刹车，刹车的方法是列车才有的，司机只是给列车发了一个信号。
总结：专家模式：谁拥有数据，谁才有操作这个数据的方法，就是操作这个数据的专家。

import java.lang.reflect.*;
class ReflectMethod 
{
	public static void main(String[] args) throws Exception
	{
		String str1 = "abc";

		//str1.charAt(1);
		Method methodCharAt = String.class.getMethod("charAt",int.class);
				
		System.out.println(methodCharAt.invoke(str1,1));	
		//下面是按jdk 1.4 的语法来调用
		System.out.println(methodCharAt.invoke(str1,new Object[]{2}));

	}
}

运行结果：

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

目标：写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。思考为什么要用反射方式去调。

问题：启动java程序的main方法的参数是一个字符串数组，即public static void main(String[] args),通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按照jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法。所以，在给main方法传递参数时，不能使用代码：mainMethod.invoke(null,new String[]{"xxxx"}),javac只会把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5语法理解。因此会出现参数类型不对的问题。

解决办法：mainMethod.invoke(null,new Object[]{new String[] {"xxx"}});
mainMethod.invoke(null,(Object)new String[] {"xxx"});
编译器会做特殊处理，编译时不把参数当作数组看待，也就不会把数组打散成若干参数了。

示例：

import java.lang.reflect.*;
class ReflectMain 
{
	public static void main(String[] args) throws Exception
	{		
		//通常方式：
		//TestArguments.main(new String[]{"111","222","333"});
		String startingClassName =  args[0];
		Method mainMethod = Class.forName(startingClassName).getMethod("main",String[].class);
		//mainMethod.invoke(null,new Object[]{new String[]{"111","222","333"}});
		mainMethod.invoke(null,(Object)new String[]{"111","222" ,"333"});//(Object)是对jvm说，我这是个对象，不要当成一个数组，别拆包
		//这里运行时要把类名当做参数传递进去，java ReflectMain TestArguments 

	}
}

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

运行结果：

七、数组的反射

1、具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

2、代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class.

3、基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用，
非基本类型的一维数组,既可以当作Object类型使用，又可以当作Object[]类型使用。
4、Arrays.asList()方法处理int[]和String[] 时的差异。
5、Array类用于完成对数组的反射操作。

6、思考题：怎么得到数组中的元素类型？
答案：得不到！因为：
Object [] a = new Object[] {"a",1};
a[0].getClass().getName();

示例：

import java.lang.reflect.*;
import java.util.*;
class ReflectArray 
{
	public static void main(String[] args) 
	{
		int[] a1 = new int[]{1,2,3}; 
 		Integer[] a11 = new Integer[]{1,2,3};
		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.getClass().equals(a4.getClass()));//这里如用==则报错
		System.out.println(a1.getClass().equals(a3.getClass()));
		System.out.println(a1.getClass().getName());	
		System.out.println(a1.getClass().getSuperclass().getName());			
		System.out.println(a4.getClass().getSuperclass().getName());
		
		Object aObj1 = a1;
		Object aObj2 = a4;
		//Object[] aObj3 = a1;
		Object[] aObj4 = a3;
		Object[] aObj5 = a4;

		System.out.println(a1);	
		System.out.println(a4);	

		//按jdk1.5中的，asList(T...a),把a1(即一个基本数据类型的数组)
		//当成一个Object作为参数传进去了
		System.out.println(Arrays.asList(a1));	

		//这里按jdk1.4中，asList(Object[] a),把a4字符串数组中的
		//每个字符串当作一个Object，合成一个Object数组作为参数传进去
		//区别原因：基本数据类型不是Object，而字符串是Object
		System.out.println(Arrays.asList(a4));	
		
		//如果把int[]改成 Integer[],就可以把数组中的元素当作一个Object了。
		System.out.println(Arrays.asList(a11));	


		//数组的反射应用
		Object obj = null;
		printObject(a1);	
		printObject(a4);	
		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);
	}

}

运行结果：

八、hashCode方法与HashSet类的关系

如果想查找一个集合中是否包含某个对象，大概的程序代码怎样写呢？你通常是逐个取出每个元素与要查找的对象进行比较，当发现某个元素与要查找的对象进行equals方法比较的结果相等时，则停止继续查找并返回肯定信息，否则，返回否定信息。如果一个集合中有很多个元素，如有一万，并且没有包含要查找的对象时，则意味着你的程序需要从该集合中取出一万个元素进行逐个比较才能得到结论。有人发明了一种哈希算法来提高从集合中查找元素的效率，这种方式将集合分成若干个存储区域，每个对象可以计算出一个哈希码，可以将哈希码分组，每组分别对应某个存储区域，根据一个对象的哈希码就可以确定该对象应该存储在哪个区域，如图：

HashSet就是采用哈希算法存取对象的集合，它内部采用对某个数字n进行取余的方式对哈希码进行分组和划分对象的存储区域。Object类中定义了一个hashCode()方法来返回每个java对象的哈希码，当从HashSet集合中查找某个对象时，Java系统首先调用对象的hashCode方法获得该对象的哈希码，然后根据哈希码找到相应的存储区域，最后取出该存储区域内的每个元素与该对象进行equals方法比较，这样不用遍历集合汇总的所有元素就可以得到结论。
可见，HashSet集合具有很好的对象检索性能,但是，HashSet集合存储对象的效率相对低些。

import java.util.*;
class ReflectArrayList 
{
	public static void main(String[] args) 
	{
		//Collection collections = new ArrayList();		
		Collection collections = new HashSet();

		ReflectPoint pt1 = new ReflectPoint(3,3);
		ReflectPoint pt2 = new ReflectPoint(5,5);
		ReflectPoint pt3 = new ReflectPoint(3,3);

		collections.add(pt1);
		collections.add(pt2);
		collections.add(pt3);
		collections.add(pt1); 
		
		//ArrayList时，结果为4，因为它是有序的，允许元素重复。
		//HashSet时，结果为3，因为它是无序的，元素不允许重复。
		//当覆盖hashCode和equals方法后，结果为2，因为pt3和pt1重复，故没放进去
		System.out.println(collections.size());
	}
}

ReflectPoint.java源文件：

class ReflectPoint 
{
	private int x;
	public int y;

	public String str1 = "ball";
	public String str2 = "basketball";
	public String str3 = "itcast";

	public ReflectPoint(int x,int y)
	{
		super();
		this.x = x;
		this.y = y;
	}

	@Override//覆盖hashCode方法
	public int hashCode() {  
        final int prime = 31;  
        int result = 1;  
        result = prime * result + x;  
        result = prime * result + y;  
        return result;  
    }  

	@Override//覆盖equals方法
    public boolean equals(Object obj) {  
        if (this == obj)  
            return true;  
        if (obj == null)  
            return false;  
        if (getClass() != obj.getClass())  
            return false;  
        final ReflectPoint other = (ReflectPoint) obj;  
        if (x != other.x)  
            return false;  
        if (y != other.y)  
            return false;  
        return true; 
	}
	
	
	@Override
	public String toString()
	{
		return str1 + ":" +str2 + ":" + str3;
	}
	
}

运行结果：

九、反射的作用-->实现框架功能

1、框架与框架要解决的核心问题
我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架。用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别：工具类被用户的类调用，而框架则是调用用户提供的类。

2、框架要解决的核心问题
我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序。我写的框架程序怎么样才能调用到你以后写的类（门窗）呢？因为在写程序时无法知道要被调用的类名，所以，在程序中无法直接new某个类的实例对象了，而要用反射方式来做。