Java反射基础应用

类定义：

package test;

public class Car {
	private int year;
	private String name;
	private float price;
	/**
	 * 无参构造器
	 */
	public Car() {
		super();
	}
	/**
	 * 一个参数的构造器
	 * @param name
	 */
	public Car(String name){
		super();
		this.name = name;
	}
	/**
	 * 多个参数的构造器
	 * @param year
	 * @param name
	 * @param price
	 */
	public Car(int year, String name, float price) {
		super();
		this.year = year;
		this.name = name;
		this.price = price;
	}

	@Override
	public String toString() {
		return "Car [year=" + year + ", name=" + name + ", price=" + price
				+ "]";
	}
	
	/**
	 * 私有方法
	 * @return
	 */
	private void testPrivate(){
		
	}
	/**
	 * protected方法
	 * @return
	 */
	protected void testProtect(){
		
	}
	public void testInvoke(int i,String str){
		System.out.println("测试testInvoke成功:"+i+","+str);
	}
	public int getYear() {
		return year;
	}
	public void setYear(int year) {
		this.year = year;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public float getPrice() {
		return price;
	}
	public void setPrice(float price) {
		this.price = price;
	}
	
}

反射应用：

package test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * 反射
 * @author Administrator
 *
 */
public class Invoke {
	public static void main(String[] args) throws Exception {
		System.out.println("*********无参构造器*********");
		Car car = (Car)noParaCreateInstance(Car.class);
		car.setName("maibahe");
		System.out.println(car);
		
		System.out.println("*********一个参数构造器*********");
		Car car2 = (Car)createInstanceByPara(Car.class,"benchi");
		System.out.println(car2.toString());
		
		System.out.println("*********多个个参数构造器*********");
		Car car3 = (Car)createInstanceByParas(Car.class, 5, "kaidilake", (float) 56.70);
		System.out.println(car3.toString());
		
		System.out.println("***********通过反射的方式获取方法*************");
		invoke1(car3); 
		
		System.out.println("***********通过反射的方式获取方法的另一种方式*************");
		invoke2(Car.class);
		
		System.out.println("***********通过反射的方式调用方法*************");
		invoke3(car3);
		
		System.out.println("***********直接通过已知方法名以反射的方式获取方法，再以反射的方式调用方法*************");
		invoke4(car3);
		
		System.out.println("***********通过反射的方式获取属性名*************");
		invokeField(car3);
	}
	/**
	 * 对于无参的构造器通过反射的方式获取实例
	 * @param clazz
	 * @return
	 * @throws Exception
	 */
	public static Object noParaCreateInstance(Class clazz) throws Exception{
		Object object = clazz.newInstance();
		return object;
	}
	/**
	 * 有一个参数的构造器通过反射的方式获取实例
	 * @param clazz
	 * @param name
	 * @return
	 * @throws Exception
	 */
	public static Object createInstanceByPara(Class clazz,String name) throws Exception{
		Constructor con = clazz.getConstructor(String.class);
		Object object = con.newInstance(name);
		return object;
	}
	/**
	 * 多个参数的构造器通过反射方式获取实例，并且参数的顺序也要和构造器的参数的顺序一致
	 * @param clazz
	 * @param year
	 * @param name
	 * @param price
	 * @return
	 * @throws Exception
	 */
	public static Object createInstanceByParas(Class clazz,int year,String name,float price) throws Exception{
		Constructor con = clazz.getConstructor(int.class,String.class,float.class);
		Object object = con.newInstance(year,name,price);
		return object;
	}
	/**
	 * 通过反射的方式获取方法
	 * @param obj
	 * @throws InvocationTargetException 
	 * @throws IllegalAccessException 
	 * @throws IllegalArgumentException 
	 */
	public static void invoke1(Object obj) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException{
		//获取当前类(不包括父类)的所有方法(包括private方法和protected方法)
		Method[] methods = obj.getClass().getDeclaredMethods();
		//获取当前类以及其父类的所有方法(不包括private方法和protected方法)
		methods = obj.getClass().getMethods();
		for(Method m:methods){
			System.out.println(m.getName());
//			if("testInvoke".equals(m.getName())){
//				m.invoke(obj, null);
//			}
		}
	}
	/**
	 * 通过反射的方式获取方法的另一种方式，直接传递一个.class参数
	 * @param clazz
	 */
	public static void invoke2(Class clazz){
		//获取当前类(不包括父类)的所有方法(包括private方法和protected方法)
		Method[] methods = clazz.getDeclaredMethods();
		//获取当前类以及其父类的所有方法(不包括private方法和protected方法)
		methods = clazz.getMethods();
		for(Method m:methods){
			System.out.println(m.getName());
		}
	}
	/**
	 * 通过反射的方式调用方法
	 * @param obj
	 * @throws IllegalArgumentException
	 * @throws IllegalAccessException
	 * @throws InvocationTargetException
	 */
	public static void invoke3(Object obj) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException{
		//获取当前类(不包括父类)的所有方法(包括private方法和protected方法)
		Method[] methods = obj.getClass().getDeclaredMethods();
		//获取当前类以及其父类的所有方法(不包括private方法和protected方法)
		methods = obj.getClass().getMethods();
		for(Method m:methods){
			if("testInvoke".equals(m.getName())){
				//通过反射的方式调用方法：m就是方法，即：方法.invoke(obj,para)，方法调用方法自己
//				m.invoke(obj, null);如果方法无参数则为null
				m.invoke(obj, 3,"good");//如果方法有多个参数，则用逗号隔开
			}
		}
	}
	/**
	 * 直接通过已知方法名以反射的方式获取方法，再以反射的方式调用方法
	 * @param obj
	 * @throws SecurityException
	 * @throws NoSuchMethodException
	 * @throws IllegalArgumentException
	 * @throws IllegalAccessException
	 * @throws InvocationTargetException
	 */
	public static void invoke4(Object obj) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
		Method method = obj.getClass().getMethod("testInvoke", int.class,String.class);//若方法无参数则第二个参数用null代替
		method.invoke(obj, 5,"fuck");
	}
	/**
	 * 以反射的方式获取属性
	 * @param obj
	 * @throws Exception
	 */
	public static void invokeField(Object obj) throws Exception{
		//获取当前类(不包括父类)的所有属性(包括private属性和protected属性)
		Field[] fields = obj.getClass().getDeclaredFields();
		//获取当前类以及其父类的所有属性(不包括private属性和protected属性)
		fields = obj.getClass().getFields();
		for(Field f:fields){
			System.out.println(f.getName());
		}
	}
	/**
	 * 通过反射的方式获取类似于"@Override"这类东西
	 * @param obj
	 * @throws Exception
	 */
	public static void invokeAnnotation(Object obj) throws Exception{
		Annotation[] annotations = obj.getClass().getAnnotations();
	}
}