标签：java   反射   class   reflect   

前言

反射提供了一种动态的功能，这种动态功能非常强大。它主要体现在通过反射相关的API，就可以知道一个陌生

的Java类的所有信息，包括属性、方法、构造器等。而且元素完全可以在运行时动态的进行创建或调用，而不必在

JVM运行时就进行确定。通过查阅相关资料，进行了整理，本篇也是基于下面文章进行扩充。

       《http://blog.csdn.net/mark_yangs/article/details/47427037》             

反射的原理是什么

严格意义上来讲，Java并不是动态语言，它并没有Perl和Python那样灵活。但是，Java的反射机制却让它显得动

态起来。

一般情况下，如果想生成这个类的对象时，运行这个程序的JVM会确认这个类的Class对象是否已经加载。如果

尚未加载，JVM就会根据类名查找.class文件，并将其载入，一旦这个类的Class对象被载入内存，它就可以被用来创

建这个类的所有对象。

另外，对于一个未知类型的引用来说，通常会采用强制类型转换的形式来得到开发者想要的类型引用，如果执行

了一个错误的类型转换，就会抛出一个ClassCastException异常。

  在以上两个过程中，Class类一直都在起作用。因为Class类实例包含的是一个Java类的全部信息，包括类名、方

法、属性等。换句话来说，也就是Class对象就是代表一个类的类。

Java用Class类来代表了所有的类，方便了开发者掌控类信息。通过Class，开发者可以得到属性、方法、构造

器、修饰符等信息。在动态的获取这些信息以后，开发者就可以用该Class创建实例、调用任何方法、访问任何属性

等操作，这些也是反射的主要用途。

反射机制相关的API主要集中在java.lang.reflect包下面，开发者也就是利用该包下面的接口和类进行相关的反射

开发。大多数的框架，如Struts、Hibernate和Spring，都会频繁地使用反射API来完成它们动态的功能。

Class类的含义和作用是什么

Class类在反射机制中起到了非常关键的作用，它是开发者进行反射开发的入口。从上面可以知道Class是用来记

录一个类的各种信息，它伴随着类的加载而 创建。那么，类会在什么时候被加载到JVM中呢？概括来说，一个普通的

Java类，会在以下几种情况，被加载到JVM中。

(1)需要使用该类创建对象。如下代码就会导致Stundent类被加载到JVM类中：

Student mStudent=new Student();

public class Student {
	static int count=2;
}

public class Main {
	public static void main(String[] args) {
		System.out.println(Student.count);
	}
}

ClassNotFoundException异常，实例代码如下：

public class Main {
	public static void main(String[] args) throws ClassNotFoundException {
		Class clazz=Class.forName("com.example.bill.Student");
	}
}

该如何得到这个Class对象呢？概括来说，要得到一个类的Class对象，可以通过以下几种途径。

(1)Class的forName()方法的返回值就是Class类型，也就是动态导入类的Class对象的引用。forName()方法的完

整定义如下：

public static Class<?> forName(String className) throws ClassNotFoundException

Class<Student> clazz=Student.class;

类的父类，所以，所有的对象都可以使用该方法得到它运行时类的Class对象，实例代码如下：

public class Main {
	public static void main(String[] args) throws ClassNotFoundException {
		Student mStudent=new Student();
		Class<Student> clazz=(Class<Student>) mStudent.getClass();
	}
}

以及调用newInstance()方法来创建新的实例对象，还有其他一些功能方法。

如何操作类的成员变量

Field类，代表的是类的属性（字段），也被称为成员变量。反射可以获取到它的对象，Field对象通过Class类的

getDeclaredField()或getDeclaredFields方法获取到，处于java.lang.reflect包下。Field提供有关类或接口的单个字段

的信息，以及对它的动态访问权限，反射的字段可能是一个静态的字段或实例的字段。

Field的方法主要分为两个类，即getXXX和setXXX。其中getXXX是用于获取某个对象的该字段的值，并且有一

定的类型规定，例如，getFloat()，而setXXX则是用于设置值，它们一般有两个参数，一个是对象引用，另一个则是

需要设置的值。

以下为一个Field的使用示例，通过反射来比较两个对象的大小：

public class FieldTestClass {
	public String name;
	public int age;
	
	public FieldTestClass(String name,int age){
		super();
		this.name=name;
		this.age=age;
	}
}

public class Main {
	public static void main(String[] args) throws ClassNotFoundException {
		FieldTestClass obj1=new FieldTestClass("bill1",100);
		FieldTestClass obj2=new FieldTestClass("bill2", 200);
		System.out.println(compare(obj1, obj2).name);
	}
	
	private static FieldTestClass compare(FieldTestClass obj1,FieldTestClass obj2){
		try {
			Field field1=obj1.getClass().getDeclaredField("age");
			Field field2=obj2.getClass().getDeclaredField("age");
			int val1=(Integer)field1.get(obj1);
			int val2=(Integer)field2.get(obj2);
			if(val1>val2){
				return obj1;
			}else{
				return obj2;
			}
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		
		return null;
	}
	
}

值得注意的是，如果我们将FieldTestClass中的age设置成private,也就是私有属性时，程序会报

IllegalAccessException异常。

如何操作类的方法

Method类，代表的是类的方法。与Field类似，反射可以获取到它的对象，使用它的方式则是动态调用，Method

对象通过Class类的getMethod()或getMethods()方法获取到，也处于java.lang.reflect包下，Method提供关于类或接口

中的某个方法（以及如何访问该方法）的信息，所反映的方法可能是类方法或实例方法（包括抽象方法在内）。

Method类中使用最多的方法是invoke(),它的含义就是方法调用。它的第一个参数为Class所代表的类的一个实例

对象，以后则是一个不定长的Object类型的参数列表，它是Method对象所代表的方法需要的参数列表。

以下为一个Method的使用实例，通过命令行参数来实现方法的动态调用：

public class MethodTestClass {
	public void m1(){
		System.out.println("m1.....");
	}
	public void m2(){
		System.out.println("m2.....");
	}
}

public class CallMethodTest {
	public static void main(String[] args) {
		args = new String[] { "m1" };
		String methodName = args[0];
		if (methodName != null) {
			Class<MethodTestClass> clazz = MethodTestClass.class;
			try {
				Method m = clazz.getDeclaredMethod(methodName);
				if (m != null) {
					MethodTestClass obj = clazz.newInstance();
					m.invoke(obj);
				}
			} catch (NoSuchMethodException e) {
				e.printStackTrace();
			} catch (SecurityException e) {
				e.printStackTrace();
			} catch (InstantiationException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				e.printStackTrace();
			}
		}
	}
}

注意如果指定的方法名不存在，程序会报NoSuchMethodException异常；如果将方法的权限设置成private,也就是私

有属性时，程序会报IllegalAccessException异常。

如何利用反射机制访问类的私有成员

根据Java的语法规则，类的私有成员（包括私有的成员变量和方法）只能被内部的方法所访问。但是，通过反射

机制，却可以访问一个类的所有成员，包括私有成员在内。

如果开发者在开发反射机制程序的时候，对待私有成员像公有成员一样，那就会遇到一个异常的抛出，以下程序

可以访问私有成员：

public class PrivateTestClass {
	private String field;
	public PrivateTestClass(String field){
		super();
		this.field=field;
	}
}

public class PrivateTest {
	public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
		PrivateTestClass obj=new PrivateTestClass("bill");
		Class clazz=obj.getClass();
		Field f=clazz.getDeclaredField("field");
		f.setAccessible(true);//访问性设置成true
		System.out.println(f.get(obj));
	}
}

程序输出结果：bill

从以上代码来看，私有的成员变量field是可以被成功访问的。其中比较关键一行代码就是调用Field的

setAccessible()方法，让field属性变得可以访问。

-------------------------------------------------------------------------------------------------------------------------------------------------------

转载请注明出处：http://blog.csdn.net/hai_qing_xu_kong/article/details/47614679情绪控

Java的反射机制

标签：java   反射   class   reflect   

原文地址：http://blog.csdn.net/hai_qing_xu_kong/article/details/47614679