反射代码块，自己理解

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Scanner;
import java.util.prefs.PreferenceChangeEvent;

public class Test {

	public static void main(String[] args) throws NoSuchMethodException {
		// ============================打印类的信息===============================
		Class c = Array.class;
		// 获得包名
		String packageName = c.getPackage().getName();
		System.out.println(packageName);
		// 获得Class的访问级别和名称
		int mod = c.getModifiers();
		String classMod = Modifier.toString(mod);
		System.out.print(classMod);
		String className = c.getName();
		System.out.print(" class " + className + "{\n");
		// 获取成员变量
		Field[] fields = c.getDeclaredFields();
		for (Field field : fields) {
			// 获取成员变量的访问修饰符
			mod = field.getModifiers();
			String fieldMod = Modifier.toString(mod);
			System.out.print(fieldMod);
			// 获取成员变量的类型
			Class type = field.getType();
			String typeName = null;
			// 如果是数组，后面就加中括号
			if (type.isArray())
				typeName = type.getComponentType().getName() + "[]";
			else
				typeName = type.getComponentType().getName();

			System.out.print(" " + typeName);
			// 获取成员变量的名称
			System.out.print(" " + field.getName() + ";\n");
		}
		try {
			// 获取构造方法
			Constructor[] cons = c.getDeclaredConstructors();
			for (Constructor con : cons) {
				// 获取构造器方法的访问修饰符
				mod = con.getModifiers();
				String conMod = Modifier.toString(mod);
				System.out.print(conMod);
				// 获取构造器方法的名称
				System.out.print(" " + con.getName() + "(");
				// 获取构造器方法的形式参数列表
				Class[] paras = con.getParameterTypes();
				for (int i = 0; i < paras.length; i++) {
					// 用逗号分隔开
					if (i > 0)
						System.out.print(",");

					// 如果是数组，要加上中括号
					if (paras[i].isArray())
						System.out.print(paras[i].getComponentType().getName() + "[]");
					else
						System.out.print(paras[i].getName());
				}
				System.out.print("){}\n");
			}
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		// 获取成员方法
		Method[] methods = c.getDeclaredMethods();
		for (Method method : methods) {
			// 获取成员方法的访问修饰符
			mod = method.getModifiers();
			String methodMod = Modifier.toString(mod);
			System.out.print(methodMod);
			// 获取成员方法的返回类型
			Class returnType = method.getReturnType();
			// 判断返回参数类型是否是数组类型
			if (returnType.isArray())
				System.out.print(" " + returnType.getComponentType().getName() + "[]");
			else
				System.out.print(" " + returnType.getName());
			// 获取成员变量的名称
			System.out.print(" " + method.getName() + "(");
			// 获取成员变量的形式参数列表
			Class[] paras = method.getParameterTypes();
			for (int i = 0; i < paras.length; i++) {
				// 用逗号分隔开
				if (i > 0)
					System.out.print(",");

				// 如果是数组，要加上中括号
				if (paras[i].isArray())
					System.out.print(paras[i].getComponentType().getName() + "[]");
				else
					System.out.print(paras[i].getName());
			}
			System.out.print("){}\n");
		}

		// ============================调用方法==========================

		// 用newInstance()方法获取实例化对象
		try {
			Array a = (Array) c.newInstance();
			// 实例化了Array，调用该对象不带参数的构造器（默认构造器）
			// 可以调用可访问修饰的方法和成员变量
		} catch (InstantiationException | IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		// 调用构造器
		try {
			// new个Class类{传递参数列表.class}
			Constructor con = c.getDeclaredConstructor(new Class[] { int[].class });
			int num[] = { 7, 5, 1, 8, 32, 45, 2, 4 };
			Object o = con.newInstance(new Object[] { num });
			Array a = (Array) o;
			// 只能调用可访问的构造器

		} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
				| InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		// 调用方法
		// 前面的是调用方法的名称，后面是传递参数列表
		// 如果调用可访问的方法，就用getMethod
		// 如果调用隐藏的方法，就要用getDeclaredMethod，并且要调用Method.setAccessible方法
		try {
			Array a = (Array)c.newInstance();
			Method m = c.getMethod("setArray",new Class[]{int [].class});
			int [] num = { 7, 5, 1, 8, 32, 45, 2, 4 };
			// 第一个为要传入值的对象的对象，第二个为传递的形式参数列表
			m.invoke(a, new Object[]{num});
			// 调用private修饰的方法
			m = c.getDeclaredMethod("setArrTime", new Class[]{int [].class});
			m.setAccessible(true);
			m.invoke(a, new Object[]{num});
		
		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}
</span></span>