JAVA反射机制

概述

      JAVA反射（放射）机制：“ 程序 运行时，允许改变程序结构或 变量 类型，这种语言称为 动态语言 ”。从这个观点看，Perl，Python，Ruby是 动态语言 ，C++，Java，C#不是动态语言。但是JAVA有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

      JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

   

实践

主要用到：

 JDK 中java.lang.reflect包中的一些方法

获取类对象

package hibernate.ch03;

import hibernate.ch01.UserInfo;

public class GetClassTest {

	/**
	 * @param args
	 * 获取类对象
	 */
	
	public boolean ClassCheck(){
		
		try {
			System.out.println("第一种方式，开始通过类本身来获取对象");
			Class UserClass = this.getClass();
			System.out.println("第一种操作方式成功\n");
			System.out.println("第二种方式，通过子类的实例获取父类对象");
			UserInfo ui = new UserInfo();
			UserClass = ui.getClass();
			Class SubUserClass = UserClass.getSuperclass();
			System.out.println("第二种操作方式成功\n");
			System.out.println("第三种方式，通过类名加.class获取对象");
			Class ForClass = UserInfo.class;
			System.out.println("第三种操作方式成功\n");
			System.out.println("第四种方式，通过类名的字符串获取对象");
			Class ForName = Class.forName("hibernate.ch01.UserInfo");
			System.out.println("第四种操作方式成功\n");
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			return false;
		}
		return true;
		
		
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		GetClassTest gc = new GetClassTest();
		if(gc.ClassCheck()){
			
			System.out.println("反射初始化获得类全部成功");
			
		}else{
			
			System.out.println("反射初始化获得类错误，请检查");
		}
	}

}

获取类的一些属性和方法

package hibernate.ch03;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class GetClassName{

	/**
	 * @param args
	 * 获取类的名称
	 */
	public String getNameByClass(){
		String name = "";
		Class UserClass = this.getClass();
		name = UserClass.getName();
		return name;
	}
	
	/**
	 * 
	 * @param args
	 * 获取父类
	 */
	public String getParentClass(UserInfoMore uim){
		
		Class uimc = uim.getClass().getSuperclass();
		return uimc.getName();
	}
	/**
	 * 
	 * @param args
	 * 获取类实现的接口
	 */
public void getInterfaces(String className){
	
     try {
		     Class cl = Class.forName(className);
           Class[] ifs = cl.getInterfaces();
        for(int i = 0 ;i< ifs.length;i++){
    	 
    	 String IName = ifs[i].getName();
    	 System.out.println("获得该类的接口名称为："+IName);
        }
	} catch (Exception e) {
		// TODO: handle exception
		e.printStackTrace();
	}
     }
		
/**
 * 
 * @param args
 * 检索指定类所有的域成员
 */

public void getFieldNames(String className){
	  
	try {
		   Class cl = Class.forName(className);
		   Field[] fds = cl.getFields();
		   for(int i = 0;i < fds.length;i++){
			   
			   String fn = fds[i].getName();
			   Class tc = fds[i].getType();
			   String ft = tc.getName();
			   System.out.println("该域的名字为:"+fn+",该域的类型为："+ft);
		   }
	} catch (Exception e) {
		// TODO: handle exception
		e.printStackTrace();
	}
}
/**
 * 
 * @param className
 * 获取类的方法
 */
public void getMethods(String className){
	
	try {
		Class cl = Class.forName(className);
		Method ml[] = cl.getDeclaredMethods();
		for(int i = 0 ;i<ml.length;i++){
			
			System.out.println("开始遍历第"+(i+1)+"方法");
			Method m = ml[i];
			System.out.println("开始获得类的变量类型");
			System.out.println("方法的方法名称为："+m.getName());
			Class ptype[] = m.getParameterTypes();
			for(int j = 0;j<ptype.length;j++){
				System.out.println("方法的参数变量类型"+j+"为："+ptype[j]);
			}
			System.out.println("方法的返回类型为为："+m.getReturnType());
		}
	} catch (Exception e) {
		// TODO: handle exception
		e.printStackTrace();
	}
	
}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		GetClassName gc = new GetClassName();
		UserInfoMore uim = new UserInfoMore();
		//gc.getNameByClass();
		//获取类名称
		System.out.println(gc.getNameByClass());
		//获取父类名称
		System.out.println(gc.getParentClass(uim));
		//获取类实现的接口
		gc.getInterfaces("hibernate.ch03.Student");
		//获取类的域成员
		gc.getFieldNames("hibernate.ch03.FieldInfo");
		//获取类的方法
		gc.getMethods("hibernate.ch01.UserInfo");
		
	}

}