Java——反射方法总结

1. 获取Class类对象的方法

/*
 * Class Class.forName(String packageNameAndClassName);
 * Class 类的静态成员方法通过完整的包名.类名获取对应的.class文件的class对象
 * 同时也可以作为.class文件加载的方式
 * 
 * Class 类名.class；
 * 		通过类名.class方法，获取对应的.class对象，通常用于方法的参数类型
 * 
 * Class 类对象.getClass();
 * 		通过类对象获取对应.class的class类对象，方法参数或者说数据类型判断
 */

package com.qfedu.a_code1;


public class GetClassObject {
	public static void main(String[] args) throws ClassNotFoundException {
		System.out.println(123456);
		
		Class<?> forname = Class.forName("com.qfedu.a_code1.Person");
		
		Class<com.qfedu.a_code1.Person> cls= Person.class;
		
		Class<? extends Person> class1 = new Person().getClass();
		
		/*
		 * .class文件占用的空间独一份，不管通过哪一种方式获取对应的class对象都是同一个对象
		 */
		
		System.out.println(forname == cls);
		System.out.println(cls == class1);
		System.out.println(class1 == forname);
		System.out.println("----------------");
		
		System.out.println(forname);
		System.out.println(cls);
		System.out.println(class1);
		System.out.println(int.class);
	}
}

2. 与构造方法有关的方法

public Constructor[] getConstructors();
	获取当前Class类对象对应Java文件中，所有【public修饰构造方法的类对象数组】
	
public Constructor[] getDeclaredConstructors();
	【暴力反射】
	获取当前Class类对象对应Java文件中，所有【构造方法的类对象数组】，包括私有化构造方法。
public Constructor getConstructor(Class... initArgumentTypes);
	根据指定的数据类型，来选择对应的构造方法，这里可能会抛出异常。
	这里有且只能获取获取类内的指定数据类型public修饰构造方法类对象
	Class: 约束数据类型，当前方法所需的参数类型
		例如: 
			这里需要int类型 int.class
			这里需要String类型 String.class
			之类需要Perosn类型 Person.class
		异常:
			NoSuchMethodException
	... : 不定长参数
		构造方法需要的参数类型是很多的，有可能无参数，有可能有参数。... 不定长参数
		类约束使用，增强代码的普适性
		例如:
			这里无参数 () or (null)
			参数类型int类型 (int.class)
			参数类型int, String类型 (int.class, String.class)
	initArgumentTypes:
		参数名 初始化参数类型复数
		
public Constructor getDeclaredConstructor(Class... initArgumentTypes);
	【暴力反射】
	根据指定的数据类型，来选择对应的构造方法，这里可能会抛出异常。
	这里可以获取指定参数类型私有化构造方法和非私有化构造方法
	Class: 约束数据类型，当前方法所需的参数类型
		例如: 
			这里需要int类型 int.class
			这里需要String类型 String.class
			之类需要Perosn类型 Person.class
		异常:
			NoSuchMethodException
	... : 不定长参数
		构造方法需要的参数类型是很多的，有可能无参数，有可能有参数。... 不定长参数
		类约束使用，增强代码的普适性
		例如:
			这里无参数 () or (null)
			参数类型int类型 (int.class)
			参数类型int, String类型 (int.class, String.class)
	initArgumentTypes:
		参数名 初始化参数类型复数
		
Object newInstance(Object... initArguments);
	通过Constructor对象来调用，传入当前构造方法所需创建对象的初始化参数，创建对象。
	Object: Object类是Java中所有类的基类，这里可以传入任意类型的参数
	... : 不定长参数，因为Constructor类对象在获取的过程中，约束的参数个数都不确定，
	这里使用不定长参数来传入数据

package com.qfedu.a_code1;

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


public class GetConstructorObject {
	public static void main(String[] args) 
			throws NoSuchMethodException, 
			SecurityException, InstantiationException, 
			IllegalAccessException, IllegalArgumentException, InvocationTargetException, 
			ClassNotFoundException {
		/*
		 * 指定的包名.类名获取对应的.class类对象
		 */
		Class<?> cls = Class.forName("com.qfedu.a_code1.Person");
		
		/*
		 * 获取当前Person类内非私有化的构造方法
		 */
		Constructor<?>[] cons = cls.getConstructors();
		for (Constructor<?> constructor : cons) {
			System.out.println(constructor);
		}
		
		System.out.println("---------------");
		System.out.println();
		
		/*
		 * 暴力反射，获取Person类内的所有构造方法，包括private修饰的私有化构造方法
		 */
		Constructor<?>[] declaredConstructors = cls.getDeclaredConstructors();
		for (Constructor<?> constructor : declaredConstructors) {
			System.out.println(constructor);
		}
		
		System.out.println("--------------");
		System.out.println();
		
		/*
		 * 根据指定参数类型获取public修饰的构造方法对象
		 * 如果没有指定参数类型的构造方法，运行异常
		 */
		Constructor<?> constructor1 = cls.getConstructor();
		Constructor<?> constructor2 = cls.getConstructor(int.class);
		Constructor<?> constructor3 = cls.getConstructor(int.class, String.class);
		System.out.println(constructor1);
		System.out.println(constructor2);
		System.out.println(constructor3);
		
		System.out.println("---------------------");
		System.out.println();
		
		/*
		 * 通过暴力反射可以获取任意权限修饰符 符合参数要求的构造方法对象
		 */
		Constructor<?> declaredConstructor1 = cls.getDeclaredConstructor();
		Constructor<?> declaredConstructor2 = cls.getDeclaredConstructor(String.class);
		System.out.println(declaredConstructor1);
		System.out.println(declaredConstructor2);
		System.out.println("--------------");
		System.out.println();
		
		/*
		 * 通过无参数Constructor对象执行newInstance方法
		 */
		Person p1 = (Person) constructor1.newInstance();
		System.out.println(p1);
		System.out.println(new Person());
		System.out.println(constructor3.newInstance(1, "ljw"));
		System.out.println("--------------");
		System.out.println();
		
		/*
		 * 给予通过暴力反射获取到的非公开权限成员变量，成员方法，构造方法，操作权限
		 */
		declaredConstructor2.setAccessible(true);
		Person p2 = (Person) declaredConstructor2.newInstance("ljw");
		System.out.println(p2);
	}
}

3. 与成员方法有关的方法

Method[] getMethods();
	获取类内所有public修饰的成员方法，包括从父类继承而来的public修饰方法。

Method[] getDeclaredMethods();
	暴力反射
	获取类内所有成员方法，但是不包括从父类继承而来的方法。

Method getMethod(String methodName, Class... parameterTypes);
	根据指定的方法名和对应的参数类型，获取对应的public修饰的成员方法
	methodName: 
		方法名，指定获取的是哪一个方法
	parameterTypes:
		Class用于约束当前使用你的参数数据类型
		... 不定长参数，方法参数个数，顺序，有参无参问题
Method getDeclaredMethod(String methodName, Class... parameterTypes);
	根据指定的方法名和对应的参数类型，获取对应的成员方法，包括私有化成员方法，但是不
	包括从父类继承而来的方法
	methodName: 
		方法名，指定获取的是哪一个方法
	parameterTypes:
		Class用于约束当前使用你的参数数据类型
		... 不定长参数，方法参数个数，顺序，有参无参问题
Object invoke(Object obj, Object... arguments);
	通过Method类对象调用，执行对应的方法，需要的参数
	obj : 
		执行当前方法的执行者
	arguments:
		Object... 不定长参数，当前方法执行所需的实际参数

package com.qfedu.a_code1;

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

public class GetMethodObject {
	public static void main(String[] args) 
			throws ClassNotFoundException, 
			NoSuchMethodException, SecurityException, 
			InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		/*
		 * 根据指定的包名.类名 获取对应的.class文件类对象
		 */
		Class<?> cls = Class.forName("com.qfedu.a_code1.Person");
		
		/*
		 * 获取类内所有public修饰的成员方法，包括从父类继承而来的方法
		 */
		Method[] methods = cls.getMethods();
		for (Method method : methods) {
			System.out.println(method);
		}
		System.out.println("-----------------");
		System.out.println();
		
		/*
		 * 获取类内所有成员方法，包括私有化成员方法，但是不包括从父类继承而来的方法
		 */
		Method[] declaredMethods = cls.getDeclaredMethods();
		for (Method method : declaredMethods) {
			System.out.println(method);
		}
		System.out.println("-------------");
		System.out.println();
		
		/*
		 * 根据指定的方法名和参数类型，获取类内public修饰的成员方法
		 */
		Method game1 = cls.getMethod("game");
		Method game2 = cls.getMethod("game", String.class);
		
		System.out.println(game1);
		System.out.println(game2);
		
		System.out.println("----------------");
		System.out.println();
		
		/*
		 * 根据制定的方法名和参数类型，获取类内private修饰的成员方法
		 */
		Method declaredMethod1 = cls.getDeclaredMethod("testPrivate");
		Method declaredMethod2 = cls.getDeclaredMethod("testPrivate", String.class);
		System.out.println(declaredMethod1);
		System.out.println(declaredMethod2);
		System.out.println("----------------");
		System.out.println();
		
		Object obj = cls.getConstructor().newInstance();
		/*
		 * 执行public修饰的成员方法
		 */
		game1.invoke(obj);
		game2.invoke(obj, "WOT");
		System.out.println("----------------------");
		System.out.println();
		
		/*
		 * 通过暴力反射给予权限，执行私有化成员方法
		 */
		declaredMethod1.setAccessible(true);
		declaredMethod1.invoke(obj);
		
		declaredMethod2.setAccessible(true);
		declaredMethod2.invoke(obj, "111");
	}
}

4. 与成员变量有关的方法

Field[] getFields();
	获取类内所有public修饰的成员变量
Field[] getDeclaredFields();
	获取类内所有成员变量，包括私有化成员方法

Field getField(String fieldName);
	获取指定变量名的成员变量对象，要求是public修饰的成员变量

Field getDeclaredField(String fieldName);
	获取指定变量名的成员变量对象，包括private私有化修饰的成员变量
	
void set(Object obj, Object value);
	设置指定调用者中对应成员变量的数据
	obj : 调用者
	value: 对应当前成员变量需要赋值的内容
Object get(Object obj);
	获取指定调用者中指定成员变量的数据
	obj: 调用者

package com.qfedu.a_code1;

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

/*
 * 获取成员变量Filed对象
 */
public class GetFieldObject {
	public static void main(String[] args) throws ClassNotFoundException, 
	NoSuchFieldException, SecurityException, 
	InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
		/*
		 * 根据指定的包名.类名获取对应.class文件类对象
		 */
		Class<?> cls = Class.forName("com.qfedu.a_code1.Person");
		
		Field[] fields = cls.getFields();
		for (Field field : fields) {
			System.out.println(field);
		}
		System.out.println("--------------");
		System.out.println();
		
		Field[] declaredFields = cls.getDeclaredFields();
		for (Field field : declaredFields) {
			System.out.println(field);
		}
		System.out.println("--------------");
		System.out.println();
		
		Field field = cls.getField("test");
		System.out.println(field);
		System.out.println("---------------");
		System.out.println();
		
		Field id = cls.getDeclaredField("id");
		Field name = cls.getDeclaredField("name");
		
		System.out.println(id);
		System.out.println(name);
		System.out.println("---------------");
		System.out.println();
		
		Object obj = cls.getConstructor().newInstance();
		System.out.println(obj);
		
		field.set(obj, 20);
		System.out.println(obj);
		
		id.setAccessible(true);
		name.setAccessible(true);
		
		id.set(obj, 1);
		name.set(obj, "ljw");
		System.out.println(obj);
		
		System.out.println(field.get(obj));
		System.out.println(id.get(obj));
		System.out.println(name.get(obj));
	}
}