反射的理解和用法

1.什么是反射？
（1）Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到类对象之后，再通过类对象进行反编译，从而获取对象的各种信息。
（2）Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。

2.我们明明可以通过new 一个对象来获取类信息，那么我们为什么要使用反射呢？
我们的servlet类是如何启动的呢？如何加载到我们的JVM当中呢?答案就是使用了反射

反射的工作原理：

3.获取class对象的方式：
遇到private修饰的就要用到暴力反射 .setAccessible(true)；
（1）.Class.forName(“全类名”)：将字节码文件加载进内存，返回class对象。 //多用于配置文件，将类名定义在配置文件当中，读取文件，加载类

(2).2.类名.class: 通过类名的class获取 //一般知道类名才这么写,多用于参数的传递

(3).对象.getClass() ：getClass()方法在object类当中定义着 //多用于对象获取字节码的方式

首先定义一个person类,内部定义好成员变量，构造方法和成员方法

public class Person {
	
	private String nameString;
	private int age;
	
	public Person() {
		
	}
	
	public Person(String nameString, int age) {
		this.nameString = nameString;
		this.age = age;
	}

	public String getNameString() {
		return nameString;
	}

	public void setNameString(String nameString) {
		this.nameString = nameString;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Person [nameString=" + nameString + ", age=" + age + "]";
	}

}

定义测试类

public class refulectDemo1 {
	
	/**
	 *      1.Class.forName("全类名")：将字节码文件加载进内存，返回class对象
		2.类名.class:通过类名的class获取
		3.对象.getClass(): getClass()方法在object类当中定义着
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws Exception {
		// 1.Class.forName("全类名")：
		Class class1 = Class.forName("reflect.Person");
		System.out.println(class1);
		
		//2.类名.class:通过类名的class获取
		Class class2 = Person.class;
		System.out.println(class2);
		
		//3.对象.getClass()
		Person person = new Person();
		Class class3 = person.getClass();
		System.out.println(class3);
		
	}

}

System.out.println(class1 == class2);
System.out.println(class2 == class3);

true
true

结论：
同一个类加载器加载的文件（*.class）在一次程序运行过程中，只会被加载一次，不论你通过那种方式获取的class对象都是同一个

4.class对象常用功能
(1).类的成员变量的获取(有两种方法)

//数组的方式：
Class class1 = Class.forName("全类名");
//1.使用getFields()获取，只能获取到public修饰的变量
Field[] fields = class1.getFields();
for (Field field : fields){
    sout(field);
}


//2.使用getDeclaredFields()获取，能获取到所有修饰符修饰的变量
Field[] fields = class1.getDeclaredFields();
for (Field field : fields){
    sout(field);
}

//非数组方式：
Class aClass = Class.forName("com.qcby.reflect.Person");
System.out.println("获取Person的age属性对象");
Field age = aClass.getDeclaredField("age");
System.out.println(age);

(2).类的成员方法的获取，分有参和无参
//invoke方法的调用：一个是当前对象，一个时方法参数列表。

//数组的方式：
Method[] declaredMethods = aClass.getDeclaredMethods();
System.out.println("获取Person的所有无参的普通方法");
for (Method declaredMethod : declaredMethods) {
    System.out.println(declaredMethod);
}

//非数组方式：
Class class1 = Class.forName("全类名");
new person = new person();
//无参的方法：
//(1)使用getMethod()获取，只能获取到public修饰的方法
Method[] methods = class1.getMethod();
for (Method method: methods){
    sout(method);
}

//(2).使用getDeclaredMethod()获取，能获取到所有修饰符修饰的方法
Method[] methods = class1.getDeclaredMethod();
for (Method method: methods){
    sout(method);
}


//有参的方法：
/**
	假设类中有run(String name)和eat(String, int age)两个方法
**/
(1)使用getMethod()获取，只能获取到public修饰的方法
new person = new person();
Method method = class1.getMethod("run", String.class);
method.invoke(cat，"小白");  //invoke方法的调用：一个是当前对象，一个时方法参数列表。
Method method = class1.getMethod("eat", String.class, int.class);
method.invoke(cat);

(2)使用getDeclaredMethod()获取，能获取到所有修饰符修饰的方法
Method method = class1.getDeclaredMethod("run", String.class);
Method method = class1.getDeclaredMethod("eat", String.class, int.class);

(3).构造方法的获取：

//数组的方式：
Class aClass = Class.forName("全类名");
Constructor[] constructors = aClass.getDeclaredConstructors();
System.out.println("获取Person的所有无参的构造方法");
for (Constructor constructor : constructors) {
    System.out.println(constructor);
}

//非数组方式：
Class aClass = Class.forName("全类名");
System.out.println("获取Person的无参构造方法");
Constructor constructor = aClass.getDeclaredConstructor();
System.out.println(constructor);
System.out.println("获取Person的有参构造方法");
Constructor constructor1 = aClass.getDeclaredConstructor(String.class,Integer.class);
System.out.println(constructor1);

(4).如何使用构造方法去构造对象？
使用newInstance(参数)

public static void main(String[] args) throws Exception {
		//0.获取Person的class对象
		Class personClass = Person.class;

		//因为构造器的方法名称是相同的，不同的是参数列表，所以我们可以根据不同的参数列表来找到构造器
		Constructor constructor = personClass.getConstructor(String.class,int.class);
		System.out.println(constructor);
		//创建对象
		Object perObject = constructor.newInstance("张三",20);
		System.out.println(perObject);
		
		System.out.println("-------------------------------");
	
		Constructor constructor1 = personClass.getConstructor();
		System.out.println(constructor1);
		//创建对象
		Object perObject1 = constructor1.newInstance();
		System.out.println(perObject1);
		
		System.out.println("-------------------------------");
		Object o = personClass.newInstance();
		System.out.println(o);
	}

4.设置值：
当修饰符为public、protect、不写的时候可以直接进行设置值，比如：name.set(类名，参数1，参数2，…)；但如果修饰符为private时，因为权限太高，需要用到暴力反射

//若person类中有public修饰的name变量和private修饰的sex变量
//设置name值：
Field name = person.getDeclaredField("name");
name.set(person, "小白")；

//设置sex值，暴力反射：
Field sex = person.getDeclaredField("sex");
sex.setAccessible(true);
sex.set(person, "男");
sout(person.getSex());

同样，在获取值的时候，private修饰的也需要暴力反射。