Java基础之反射（一）

利用java的反射机制可以检查类的结构

在java.lang.reflect包中有三个类：

Filed、Method和Constructor分别用于描述类的域，方法和构造器。

这三个类都有一个叫做getName的方法，用来返回项目的名称。

还都有一个叫做getModifiers的方法，它将返回一个整数类型，用来描述修饰符的使用状况。利用Modifier.toString方法将修饰符打印出来。

下面通过一个被检测类Employee和一个测试类test1来具体的介绍java的反射机制。我把这两个类放在了自定义的reflect包下。

package reflect;

public class Employee 
{
 private String name; //姓名
 public String sex;   //性别
 protected int age;   //年龄
 int salary; 
 
 //构造函数1
 public Employee(String name,String sex,int age)
 {
	 this.name = name;
	 this.sex = sex;
	 this.age = age;
 }
 
 //构造函数2
 public Employee(String name,String sex)
 {
	 this.name = name;
	 this.sex = sex;
 }
 
 //构造函数3
 public Employee(String name)
 {
	 this.name = name;
 }
 
 public void fun()
 {
	 System.out.println("没有参数的方法");
 }
 
 public void fun(String s,int i,double d)
 {
	 System.out.println("三个参数的方法");
 }
}

下面是测试类

package reflect;

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

public class test1 
{
	public static void main(String[] args) 
	{
		//创建Employee对象jack
		Employee jack = new Employee("Jack123","men",20);
	    //获取jack对象的类型类c1
		Class c1 = jack.getClass();
		//获取c1中的构造函数，将结果存放在Constructor类型的数组中
	    Constructor constructors[] = c1.getDeclaredConstructors();
	    //遍历constructors数组，打印输出所有的构造方法
	    System.out.println("对象包含的所有构造方法：");
	    for(Constructor c:constructors)
	    {
	    	//获取构造函数名
	    	String name = c.getName();
	    	System.out.println("  ");
	    	//获得修饰符
	    	String modifiers = Modifier.toString(c.getModifiers());
	    	System.out.print(modifiers+" "); 
	    	System.out.print(name+"("); 		 	
	    	//获取构造函数的参数
	    	Class paramTypes[] = c.getParameterTypes();
	    	for(int j = 0;j<paramTypes.length;j++)
	    	{
	    		if(j>0)
	    			System.out.print(",");
	    	//输出参数类型
	    		System.out.print(paramTypes[j].getName());
	    	}
	    	System.out.println(")");
	    }
	    
	    //获取c1中的所有成员变量，将结果存放在Field类型的数组中
	    Field fields[] = c1.getDeclaredFields();
	    try 
	    {
	    	//遍历fields数组，打印输出所有的成员变量
	    	System.out.println('\n'+"对象包含的所有成员变量：");
		    for(Field f:fields)
		    {
		    	//获取成员变量的类型
		    	Class type = f.getType();
		    	//获取成员变量的变量名name
		    	String name = f.getName();
		    	//获取变量名为name的变量的value
		    	Field value = c1.getDeclaredField(name);
		    	//设置访问权限，设置为true后可以访问私有和受保护的成员变量
		    	value.setAccessible(true);
		    	//获取对象jack的变量名为name的value
		    	Object v = value.get(jack);
		    	System.out.println("  ");
		    	//获得修饰符
		    	String modifiers = Modifier.toString(f.getModifiers());
		    	if(modifiers.length()>0)
		    	System.out.print(modifiers+" ");
		    	System.out.println(type.getName()+" "+name+" = "+v+";"); 		
		    }
		    
		} 
	    catch (NoSuchFieldException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	    catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	    catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			System.out.println("没有访问权限");
		}
	    //获取c1中的所有成员方法，将结果存放在Method类型的数组中
	    Method []methods = c1.getDeclaredMethods();
	    //遍历methods数组，打印输出所有的方法
	    System.out.println('\n'+"对象包含的所有方法：");
	    for(Method m:methods)
	    {
	    	//获取方法的返回类型
	    	Class reType = m.getReturnType();
	    	//获取方法名
	    	String name = m.getName();
	    	//获得修饰符
	    	String modifiers = Modifier.toString(m.getModifiers());
	    	System.out.println("  ");
	    	if(modifiers.length()>0)
	    	System.out.print(modifiers+" ");
	    	System.out.print(reType.getName()+" "+name+"(");
	    	//获取方法的所有参数
	    	Class[] paramTypes = m.getParameterTypes();
	    	//遍历输出方法的参数
	    	for(int j = 0;j<paramTypes.length;j++)
	    	{
	    		if(j>0)
	    		{
	    			System.out.print(",");
	    		}
	    		System.out.print(paramTypes[j].getName());
	    	}
	    	System.out.println(")");	
	    }
	}
	
}