Java反射机制中常用API

Class是Reflection故事起源。针对任何您想探勘的class，唯有先为它产生一个Class object，接下来才能经由它唤起为数十多个的Reflection APIs。首先看看Class，反射的核心类，所有的操作都是围绕该类来生成的。
Java允许我们从多种管道为一个class生成对应的Class object：

 //运用Class.forName()
	Class c1 = Class.forName("java.lang.String");

	//运用getClass(),每个object都有此方法
	String str = "abc";
	Class c2 = str.getClass();

	//运用getSuperclass(),每个class对象都有此方法
	Button b = new Button();
	Class c3 = b.getClass();
	Class c4 = c3.getSuperclass();

	//运用.class 語法
	Class c5 = String.class;
	Class c6 = Integer.class;//java.lang.Integer
	Class c7 = java.awt.Button.class;
	Class c8 = int.class;//Integer.TYPE==int.class
	Class c9 = int[].class;

	//运用primitive wrapper classes(原始包装类)的TYPE语法
	Class c10 = Integer.TYPE;//表示基本类型int的Class实例,与int.class返回结果一样
	Class c11 = Byte.TYPE;
	Class c12 = Character.TYPE;
	Class c13 = Short.TYPE;
	Class c14 = Boolean.TYPE;
	Class c15 = Long.TYPE;
	Class c16 = Float.TYPE;
	Class c17 = Double.TYPE;
	Class c18 = Void.TYPE;

以下是反射的一个入门级的类：

package com.web.util;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class ReflectionUtil {

	public String name = "Gerry";
	public int age = 22;
	public Integer rank = 10;
	private int a = 1;

	public ReflectionUtil(){
	}

	public ReflectionUtil(String name,int age){
		this.name = name;
		this.age = age;
	}

	public String toString(){
		return this.name + " : " + this.age;
	}

	public String say(String s){
		System.out.println(s);
		return this.toString();
	}

	public void sayy(){
		System.out.println("无参");
	}

	public static void say(){
		System.out.println("静态方法调用时，不需要传一个对象");
	}

	/**
	 * 运行时生成instance,无参构造
	 */
	public void testConstrutor() throws Exception{
		Class c = Class.forName("com.web.util.ReflectionUtil");
		Object obj = c.newInstance();
		System.out.println(obj.toString());

		//类的一些信息
		int flag = c.getModifiers();//表示该类修饰符的 int
		Package pack = c.getPackage();
		System.out.println("包名："+pack.getName());//包名
		System.out.println(c.getName());//类的完整类名
		System.out.println("类修饰符："+Modifier.toString(flag));//类修饰符
		System.out.println("是否接口："+Modifier.isInterface(flag));//是否接口
	}

	/**
	 * 运行时生成instance,有参数的构造
	 */
	public void testConstrutorByArgs() throws Exception{
		Class c = Class.forName("com.web.util.ReflectionUtil");
		Class[] ptypes = new Class[]{String.class,int.class};//Class[] ptypes = {String.class,Integer.TYPE};
		Constructor ctor = c.getConstructor(ptypes);
		Object[] arg = {"HaiMei",23};
		Object obj = ctor.newInstance(arg);
		System.out.println(obj.toString());
	}

	/**
	 * 运行时调用method,有参数
	 */
	public void testMethodByAgrs() throws Exception{
		Class c = Class.forName("com.web.util.ReflectionUtil");
		Class ptypes[] = {String.class};
		Method m = c.getMethod("say", ptypes);
		ReflectionUtil obj = new ReflectionUtil();
		obj.name = "Gerry";
		obj.age = 40;

		Object[] arg = {"invoke say()"};
		Object r = m.invoke(obj, arg);
		System.out.println((String)r);
	}

	/**
	 * 运行时调用method,无参数
	 */
	public void testMethod() throws Exception{
		Class c = Class.forName("com.web.util.ReflectionUtil");
		Class ptypes[] = {};
		Method m = c.getMethod("sayy", ptypes);
		ReflectionUtil obj = new ReflectionUtil();
		Object[] arg = {};
		Void v = (Void) m.invoke(obj, arg); //返回值为void时
	}

	/**
	 * 运行时调用静态method,invoke时不需要传一个对象
	 */
	public void testMethodStatic() throws Exception{
		Class c = Class.forName("com.web.util.ReflectionUtil");
		Class ptypes[] = {};
		Method m = c.getMethod("say", ptypes);
		Object[] arg = {};
		m.invoke(null, arg);
	}

	/**
	 * 获取Field值、设置field值
	 */
	public void testField() throws Exception{
		ReflectionUtil obj = new ReflectionUtil();
		Class c = obj.getClass();
		Field f = c.getField("name");
		System.out.println(f.getName());
		System.out.println(f.getGenericType());//返回一个 Type 对象,该字段的声明类型
		System.out.println(f.getType());//返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型
		System.out.println((String)f.get(obj));
		f.set(obj, "Bruce");
		System.out.println((String)f.get(obj));

		f = c.getField("age");
		System.out.println((Integer)f.get(obj));
		f.set(obj,24);
		System.out.println((Integer)f.get(obj));
	}

	/**
	 * 访问Field内容
	 */
	public void testFields() throws Exception{
		ReflectionUtil r = new ReflectionUtil(); 
		Class c = r.getClass();   

		System.out.println("反射类中所有公有的属性：");   
		Field[] fPublic =c.getFields();//只能获取反射类中所有公有属性  
		for(int i=0; i<fPublic.length; i++){   
			Class cc = fPublic[i].getType();   
			System.out.println("fPublic:"+cc);   
		}

		System.out.println("反射类中所有的属性（当然也包括私有的属性）：");   
		Field[] fAll = c.getDeclaredFields();//可以获取反射类中所有的属性  
		for(int i=0; i<fAll.length; i++){   
			Class cl = fAll[i].getType();   
			System.out.println("fAll:"+cl);   
		}   

		System.out.println("反射类中私有属性的值：");   
		Field f = c.getDeclaredField("a");   
		f.setAccessible(true);   
		Integer i = (Integer)f.get(r);   
		System.out.println(i);   
	}

	/**
	 * 获取参数类型Class[]的方法  
	 */ 
	public Class[] getMethodClass(String[] type){
		Class[] c = new Class[type.length];
		for(int i=0; i<c.length; i++){
			if(!type[i].trim().equals("") || type[i] != null){
				if(type[i].equals("int") || type[i].equals("Integer")){
					c[i] = Integer.TYPE;
				}else if(type[i].equals("float") || type[i].equals("Float")){
					c[i] = Float.TYPE;
				}else if(type[i].equals("double") || type[i].equals("Double")){
					c[i] = Double.TYPE;
				}else if(type[i].equals("boolean") || type[i].equals("Boolean")){
					c[i] = Boolean.TYPE;
				}else{
					c[i] = String.class;
				}
			}
		}
		return c;
	}   

	/**
	 * 获取参数Object[]的方法
	 */   
	public Object[] getMethodObject(String[] type, String[] param){
		Object[] obj = new Object[param.length];
		for(int i=0; i<obj.length; i++){
			if(param[i] != null || !param[i].trim().equals("")){
				if(type[i].equals("int") || type[i].equals("Integer")){
					obj[i] = new Integer(param[i]);
				}else if (type[i].equals("float") || type[i].equals("Float")){
					obj[i] = new Float(param[i]);
				}else if (type[i].equals("double") || type[i].equals("Double")){
					obj[i] = new Double(param[i]);
				}else if (type[i].equals("boolean") || type[i].equals("Boolean")){
					obj[i] = new Boolean(param[i]);
				}else{
					obj[i] = param[i];
				}
			}
		}
		return obj;
	}   
}