demo-java.lang.reflect

package test.demo.reflex;

/**
 * 反射方法使用练习所使用的类
 * 
 * @author Administrator
 *
 */
class TestData {

	/**
	 * 参数一
	 */
	private String parameter1 = "testParameter1";

	/**
	 * 参数二
	 */
	private String parameter2 = "testParameter2";

	/**
	 * 参数三
	 */
	private String parameter3 = "testParameter3";

	/**
	 * 无参构造
	 */
	TestData() {
		super();
	}

	/**
	 * 一个参数构造
	 * 
	 * @param parameter1
	 *            参数一
	 */
	TestData(String parameter1) {
		super();
		this.parameter1 = parameter1;
	}

	/**
	 * 双参构造
	 * 
	 * @param parameter2
	 *            参数二
	 * @param parameter3
	 *            参数三
	 */
	TestData(String parameter2, String parameter3) {
		super();
		this.parameter2 = parameter2;
		this.parameter3 = parameter3;
	}

	/**
	 * 全参构造
	 * 
	 * @param parameter1
	 *            参数一
	 * @param parameter2
	 *            参数二
	 * @param parameter3
	 *            参数三
	 */
	TestData(String parameter1, String parameter2, String parameter3) {
		super();
		this.parameter1 = parameter1;
		this.parameter2 = parameter2;
		this.parameter3 = parameter3;
	}

	/**
	 * 打印该类的实例的所有参数
	 */
	public void print() {
		System.out.println("this is class of TestData:has there parameters");
		System.out.println("parameter1:\t" + this.parameter1);
		System.out.println("parameter2:\t" + this.parameter2);
		System.out.println("parameter3:\t" + this.parameter3);
	}

	// seter/geter——————————————————————
	public String getParameter() {
		return parameter1;
	}

	public void setParameter(String parameter) {
		this.parameter1 = parameter;
	}

	public String getParameter1() {
		return parameter2;
	}

	public void setParameter1(String parameter1) {
		this.parameter2 = parameter1;
	}

	public String getParameter2() {
		return parameter3;
	}

	public void setParameter2(String parameter2) {
		this.parameter3 = parameter2;
	}

}


package test.demo.reflex;

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

/**
 * 反射练习
 * 
 * @author Administrator
 *
 */
class ReflexDemo {

	/**
	 * 定义一个演示反射所用的类的全名
	 */
	static String testDataClassName = "test.demo.reflex.TestData";

	/**
	 * 构造
	 */
	ReflexDemo() {
		super();
	}

	public static void main(String[] args) {
		ReflexDemo reflexDemo = new ReflexDemo();
		// 通过反射来实例化一个类
		reflexDemo.reflexInitialization();

		// 分别通过直接实例化、类的.class、反射三种方法获取Class类，输出类的描述
		System.out.println("********************************");
		reflexDemo.reflexClassName();

		// 通过反射获取一个类的所有方法，包括从父类或接口继承实现的方法，并输出方法名
		System.out.println("********************************");
		reflexDemo.reflexPrintMethods();

		// 打印一个类的所有属性
		System.out.println("********************************");
		reflexDemo.reflexPrintDeclaredFields();

		// 打印一个类的所有构造器
		System.out.println("********************************");
		reflexDemo.reflexPrintConstructors();

		// Invoke无参方法调用
		System.out.println("********************************");
		reflexDemo.reflexInvokeWithoutParameter();

		// Invoke有参方法调用
		System.out.println("********************************");
		reflexDemo.reflexInvokeWithParameter();

		// 反射调用有参构造方法
		System.out.println("********************************");
		reflexDemo.reflexConstructor();

	}

	/**
	 * 通过反射来实例化一个类
	 */
	public void reflexInitialization() {
		// ********************************
		// 通过反射实例化
		System.out.println("--------通过反射实例化");
		Class<?> cla = null;
		try {
			cla = Class.forName(ReflexDemo.testDataClassName);
			// newInstance方法无法通过带参构造实例化对象
			TestData testData = (TestData) cla.newInstance();
			// 打印参数
			testData.print();
		} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
			e.printStackTrace();
		}
		// ********************************
		// 直接实例化
		System.out.println("--------直接实例化");
		// 打印参数
		new TestData().print();
	}

	/**
	 * 分别通过直接实例化、类的.class、反射三种方法获取Class类，输出类的描述
	 */
	public void reflexClassName() {
		System.out.println("--------获取类的描述");
		TestData testData = new TestData();
		Class<?> c1 = testData.getClass();
		Class<?> c2 = TestData.class;
		Class<?> c3 = null;
		try {
			c3 = Class.forName(ReflexDemo.testDataClassName);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		System.out.println(c1.getName());
		System.out.println(c2.getName());
		System.out.println(c3.getName());

	}

	/**
	 * 通过反射获取一个类的所有方法，包括从父类或接口继承实现的方法，并输出方法名
	 */
	public void reflexPrintMethods() {
		System.out.println("--------获取一个类的所有方法");
		Class<?> cla = null;
		try {
			cla = Class.forName(ReflexDemo.testDataClassName);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		Method[] methods = cla.getMethods();
		for (Method method : methods) {
			System.out.println(method.getName());
		}
	}

	/**
	 * 打印一个类的所有属性
	 */
	public void reflexPrintDeclaredFields() {
		System.out.println("--------打印一个类的所有属性");
		Class<?> cls = null;
		try {
			cls = Class.forName(testDataClassName);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		Field[] declaredFields = cls.getDeclaredFields();
		for (Field field : declaredFields) {
			System.out.println(field.getName());
		}
	}

	/**
	 * 打印一个类的所有构造器
	 */
	public void reflexPrintConstructors() {
		System.out.println("--------打印一个类的所有构造器");
		Class<?> cls = null;
		try {
			cls = Class.forName(testDataClassName);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		Constructor<?>[] constructors = cls.getDeclaredConstructors();
		System.out.println(constructors.length);
		for (Constructor<?> constructor : constructors) {
			System.out.println(constructor.getName());
		}
	}

	/**
	 * Invoke无参方法调用
	 */
	public void reflexInvokeWithoutParameter() {
		System.out.println("--------Invoke无参方法调用");
		Class<?> cls = null;
		try {
			cls = Class.forName(testDataClassName);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		Method[] methods = cls.getMethods();
		for (Method method : methods) {
			if (method.getName().startsWith("get") && !method.getName().equals("getClass")) {
				try {
					String string = (String) method.invoke(cls.newInstance());
					System.out.println(method.getName() + "\t" + string);
				} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException
						| InstantiationException e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * Invoke有参方法调用
	 */
	public void reflexInvokeWithParameter() {
		System.out.println("--------Invoke有参方法调用");
		Class<?> cls = null;
		try {
			cls = Class.forName(testDataClassName);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		try {
			Method method = cls.getMethod("setParameter", String.class);
			Object newInstance = cls.newInstance();
			method.invoke(newInstance, "from reflex invoke");
			Method methodPrint = cls.getMethod("print");
			methodPrint.invoke(newInstance);
		} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException
				| InvocationTargetException | InstantiationException e) {
			e.printStackTrace();
		}

	}

	/**
	 * 反射调用有参构造方法
	 */
	public void reflexConstructor() {
		// 加载类
		Class<?> cls = null;
		try {
			cls = Class.forName(testDataClassName);
		} catch (ClassNotFoundException e1) {
			e1.printStackTrace();
		}
		// 指明参数类型
		@SuppressWarnings("rawtypes")
		Class[] paramTypes = { String.class, String.class };
		// 设置参数
		Object[] paramValues = { "this is frist param set from reflexConstructor",
				"this is second param set from reflexConstructor" };
		try {
			// 创建构造器对象，该方法只能获取public构造，否则会抛出NoSuchMethodException异常
			Constructor<?> constructor = cls.getConstructor(paramTypes);
			// 传入参数，创建对象
			TestData newInstance = (TestData) constructor.newInstance(paramValues);
			// 调用print()打印该对象所有参数
			newInstance.print();
		} catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException
				| IllegalArgumentException | InvocationTargetException e) {
			e.printStackTrace();
		}
	}
}