java中的反射机制

[align=center][b][b]java的反射机制[/b][/b]
关键词:反射 [/align]

先让我们看看java中的反射机制所能实现的功能:
一：对于任意一个类，都能够知道这个类的所有属性和方法
1: 在运行时判断任意一个对象所属的类；
2:在运行时构造任意一个类的对象；
3:在运行时判断任意一个类所具有的成员变量和方法；

二:对于任意一个对象，都能够调用它的任意一个方法
4:在运行时调用任意一个对象的方法；
5:生成动态代理。

这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

下面我们以一个简单的实例来讲解java的反射机制;
1：其中测试类1主要是为大家展示如可能过一个对象去获得与之相关的一系列信息。
2：而测试类2主要是展示如何通过反射机制实现在对象上调用方法。

[code]//这是共同的接口
public interface IVehicle {

public void startMe();//启动
public int forward(int dins);//前进
//有多少油
public int getEnergy();
}

//这是实现了该接口的一个类
public class BMW implements IVehicle{
	public static final String company="宝马公司";
	public int energy;//能量

	public BMW(){
		this.energy = 10;
	}

	public BMW(int engery){
		this.energy = engery;
	}
	//启动
    public void startMe(){
    	System.out.println("BMW启动...");

    }
    //前进
   public int forward(int dins){
	   energy -= dins/100;
	   System.out.println("BWM前进"+dins);
	   return energy;
   }

  //有多少能量

   public int getEnergy(){
	   return this.energy;
   }
}

//测试类1

public class ReflectionText {

	public static void main(String args[]){
		BMW b =  new BMW();
		//叛断对象所属的类型
		if(b instanceof BMW){
			System.out.println("是BMW类型");
		}

		if(b instanceof IVehicle){
			System.out.println("是IVehicle类型");
		}
	/**
	 * 提取类的详细信息	
	 */
		Class c = b.getClass();
		Class cd = BMW.class;
		System.out.println("BMW.class="+cd.getName());
		String className = c.getName();
		System.out.println("类的名字是:"+className);
		//得到类中的方法对象数组
		java.lang.reflect.Method[] methods = c.getMethods();
		ReflectionText.printMethodInfo(methods);
		//得到类定义的构造器对象数组
		java.lang.reflect.Constructor[] cons = c.getConstructors();
		//得到类定义的属性对象数组
		java.lang.reflect.Field[] fields = c.getFields();
		//ReflectionText.printFileInfo(fields);
		//得到类的直接父类对象
		Class superClass = c.getSuperclass();
		//ReflectionText.printSuper(superClass);
		//得到类所有实现的接口类对象数组
		Class[] interfaces = c.getInterfaces();
		//ReflectionText.printInterface(interfaces);
	}

	/**
	 *提取属性的详细信息 
	 */

	private static void printFileInfo(java.lang.reflect.Field[] fields){
		System.out.println("共有属性:"+fields.length);
		for(java.lang.reflect.Field field : fields){
			System.out.println("属性的名字是:"+field.getName());
			System.out.println("属性的类型是:"+field.getType());
			//得到属性的访问限定符
			int mType = field.getModifiers();
			//叛断是何种限定符
			if(java.lang.reflect.Modifier.isPublic(mType)){
				System.out.println("isPublic");
			}
			if(java.lang.reflect.Modifier.isPrivate(mType)){
				System.out.println("isPrivate");
			}
			if(java.lang.reflect.Modifier.isProtected(mType)){
				System.out.println("isProtected");
			}
			if(java.lang.reflect.Modifier.isFinal(mType)){
				System.out.println("isFinal");
			}
			if(java.lang.reflect.Modifier.isAbstract(mType)){
				System.out.println("isAbstract");
			}
		}

	}
	/**
	 * 得到所有接口名字
	 */
	 private static void printInterface(Class[] interfaces){
		 for(Class c :interfaces){
         System.out.println("接口名："+c.getName());
         Class[] cs = c.getInterfaces();
         printInterface(cs);
		 }
	 }
	/**
	 * 输出所有父类名字
	 */

	 private static void printSuper(Class superClass){
	         System.out.println("接口名："+superClass.getSuperclass());
	         Class ss = superClass.getSuperclass();
	         if(null != ss){
	        	 printSuper(ss);
	         }
	 }

	/**
	 * 提取方法详细信息
	 */

	 private static void printMethodInfo(java.lang.reflect.Method[] methods){
		 for(java.lang.reflect.Method method : methods){
			 int t = method.getModifiers();
			 System.out.println("限定符是："+t);
			 String name = method.getName();
			 System.out.println("方法名是是："+name);
			 Class returnType = method.getReturnType();
			 System.out.println("反回值是："+returnType);
			 //参类类型数组
			 Class ps[] = method.getParameterTypes();
//			 for(Class p : ps){
//				 System.out.println("参数名是："+p.getName());
//			 }
			 Class es[] = method.getExceptionTypes();
		 }
	 }
	/**
	 * 打印构造器信息
	 */

	 private static void printConstructorInfo(java.lang.reflect.Constructor[] cons){

	 }		
}

//测试类2，主要实现通过反射机制在对象上调用方法
public class text2 {
	//动态创建凡是实现了IVehicle接口的类,只要知道你想知类的名字即可
	public static IVehicle createIVehicle(String className){
		try{
			IVehicle v = (IVehicle)Class.forName(className).newInstance();//动态创建对象
			return v;
		}catch(Exception ef){
			ef.printStackTrace();
		}
		return null;
	}
	public static void main(String args[]){
		//BMW bmw = new BMW();
		IVehicle bmw = text2.createIVehicle("BMW");
		bmw.startMe();//测试打印
//		IVehicle bmw2 = new BMW();
//		bmw2.startMe();
//		//得到所在的类，该处也可以写成,BMW.Class();
		Class destClass = bmw.getClass();
		java.lang.reflect.Method[] methods = destClass.getMethods();//得到这个类的所有定义的方法数组
		for(java.lang.reflect.Method m : methods){
			Class ps[] = methods[1].getParameterTypes();//得到方法参数类型表
			text2.invokeTest(bmw, "forward",ps);
			break;
		}

	}

	//在对象上调用方法
	public static void invokeTest(IVehicle bmw,String destName,Class[] paraType){
		try{
			//得到所在的类
		Class destClass = bmw.getClass();

		//查询要调用的类
		java.lang.reflect.Method destMethod = destClass.getMethod(destName, paraType);
		if(null != destMethod){
			//调查用方法，传入参数
			Object obj = destMethod.invoke(bmw, 300);
			System.out.println(destMethod+"调用的结果是"+obj);
		}


		}catch(Exception ef){
			ef.printStackTrace();
		}
	}
}

以上就是java反射机制的简单用法，最重要需要理解的我觉得是“动态”二字，如果想更好的理解，你可以将其它静态对比。你就会发现，它们的区别在于，可以实验动态创建对象，获取相关的类信息。