[Java开发之路]（14）反射机制

// 创建Book实例对象
Book book = new Book(); 

// Class的构造函数是私有的，只有JVM才能创建Class实例对象
Class class1 = new Class();  // 错误

public final class Class<T> implements java.io.Serializable,
                              java.lang.reflect.GenericDeclaration,
                              java.lang.reflect.Type,
                              java.lang.reflect.AnnotatedElement {
 
    /*
     * Constructor. Only the Java Virtual Machine creates Class
     * objects.
     */
    private Class() {}
 
    ....
 
}

		try {
			Class class3 = Class.forName("com.qunar.bean.Book");
			// 通过类类型的newInstance方法创建实例对象
			Book book2 = (Book)class3.newInstance();
			book2.setPrice("23.4");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}

package com.qunar.reflect;
 
public class ReflectDemo {
 
	public static void main(String[] args) {
		// int的类类型
		Class class1 = int.class;
		Class class2 = String.class;
		Class class3 = double.class;
		Class class4 = Double.class;
		Class class5 = void.class;
		
		System.out.println("class1->" + class1.getName());
		System.out.println("class2->" + class2.getName());
		System.out.println("class3->" + class3.getName());
		System.out.println("class4->" + class4.getName());
		System.out.println("class5->" + class5.getName());
	}
}

// 只打印简单名称（不包含包名称）
System.out.println("class2->" + class2.getSimpleName()); // String

	/**
	 * 打印类成员方法信息（public函数，包括父类继承而来的）
	 * @param object
	 */
	public static void PrintClassPublicFunction(Object object){
		// 获取类的信息，首先获取类的类类型
		// 传递的是哪个子类的对象 c 就是该子类的类类型
		Class c = object.getClass();
		System.out.println("类的全称是：" + c.getName());
		// 一个成员方法就是一个method对象
		// getMethods方法是获取的是所有public的函数，包括父类继承而来的
		Method[] methods = c.getMethods();
		for (Method method : methods) {
			// 获取方法返回值类型的类类型
			Class returnType = method.getReturnType();
			System.out.print(returnType.getName() + " ");
			
			// 获取方法的名称
			System.out.print(method.getName() + "(");
			
			// 获取方法参数
			// 得到方法参数列表中类型的类类型
			Class[] paramTypes = method.getParameterTypes();
			int size = paramTypes.length;
			for (int i = 0;i < size;++i) {
				if(i != 0){
					System.out.print(",");
				}//if
				System.out.print(paramTypes[i].getName());
			}//for
			System.out.println(")");
		}//for
	}

	/**
	 * 打印类成员变量信息
	 * @param object
	 */
	public static void PrintClassFiled(Object object){
		// 获取类的信息，首先获取类的类类型
		// 传递的是哪个子类的对象 c 就是该子类的类类型
		Class c = object.getClass();
		
		/* 成员变量也是对象，java.lang.reflect.Field 类封装了关于成员变量的操作
		 * getFields()方法获取的是所有的public的成员变量的信息
		 * getDeclaredFields()获取的是该类自己声明的成员变量的信息
		 */
		Field[] fields = c.getDeclaredFields();
		for (Field field : fields) {
			// 得到成员变量的类型的类类型
			Class fieldType = field.getType();
			// 得到成员变量的类型
			System.out.print(fieldType.getName() + " ");
			// 得到成员变量的名称
			System.out.println(field.getName());
		}//for
	}

	/**
	 * 打印类构造函数信息
	 * @param object
	 */
	public static void PrintClassConstructor(Object object){
		// 获取类的信息，首先获取类的类类型
		// 传递的是哪个子类的对象 c 就是该子类的类类型
		Class c = object.getClass();
				
		/* 构造函数也是对象，java.lang.reflect.Constructor 类封装了关于构造函数的操作
		 * getConstructors()方法获取的是所有的public的构造函数的信息
		 * getDeclaredConstructors()获取的是该类自己声明的构造函数的信息
		 */
		Constructor[] constructors = c.getConstructors();
		for (Constructor constructor : constructors) {
			// 构造函数的名称
			System.out.print(constructor.getName() + "(");
			// 获取构造函数的参数列表，得到的是参数列表的类类型
			Class[] paramTypes = constructor.getParameterTypes();
			int size = paramTypes.length;
			for(int i = 0;i < size;++i){
				if(i != 0){
					System.out.print(",");
				}//if
				// 得到参数名称
				System.out.print(paramTypes[i].getName());
			}//for
			System.out.println(")");
		}//for
	}

package com.qunar.reflect;
 
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
 
import com.qunar.bean.Calculates;
 
 
public class ReflectDemo {
 
	public static void main(String[] args) {
		// 获取类的信息，首先获取类的类类型
		Calculates calculates = new Calculates();
		calculates.setNum1(20);
		calculates.setNum2(40);
		
		Class c = calculates.getClass();
						
		/* getMethod()方法获取的是public的方法信息
		 * getDeclaredMethod()获取的是该类自己声明的方法的信息
		 */
		try {
			// 获取方法  名称和参数列表共同决定
			// Method method = c.getDeclaredMethod("add", new Class[]{int.class,int.class});
			Method method = c.getDeclaredMethod("add", int.class,int.class);
			// 方法的反射 
			// 对于calculates.add(10,40)来说，方法的反射操作是用method方法调用 和 calculates.add(10,40)的效果一样
			// int result = (int)method.invoke(calculates, new Object[]{10,40});
			int result = (int)method.invoke(calculates, 10,40);
			System.out.println(result);
			
			// 对于没有参数的方法
			Method method2 = c.getDeclaredMethod("print");
			method2.invoke(calculates);
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
	}
}