Reflect

package com.briup.day13;

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

import com.briup.day11.Student;

public class ReflectTest {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
	//1.获取类镜像,参数是权限类名
	Class clz=Class.forName("com.briup.day11.Student");
	//2.获取该类中的所有属性
	  Field[] f = clz.getDeclaredFields();
	  for(Field temp:f) {
		  //获取属性的数据类型
		  Class c = temp.getType();
		  //获取属性的修饰符
		  int m = temp.getModifiers();
		  //获取属性名
		  String name = temp.getName();
		  //System.out.println(m+":"+c+":"+name);
	  }
	//3.获取所有的方法
	   Method[] methods = clz.getDeclaredMethods();
	   for(Method temp:methods) {
		   //获取方法名
		   String name = temp.getName();
		   //获取返回值类型
		   Class r = temp.getReturnType();
		   //获取修饰符
		   int m = temp.getModifiers();
		   //获取参数列表
		   Class[] c = temp.getParameterTypes();
		   String str="";
		   for(Class t:c) {
			   str+=t;
		   }
		   //System.out.println(m+":"+r+":"+name+":"+str);
	   }
	   //4.获取构造器
	   Constructor[] cst = clz.getDeclaredConstructors();
	     for(Constructor sutt:cst) {
	    	  //获取方法名
			   String name = sutt.getName();
			   //获取修饰符
			   int m = sutt.getModifiers();
			   //获取参数列表
			   Class[] c = sutt.getParameterTypes();
			   String str="";
			   for(Class t:c) {
				   str+=t;
			   }
			  // System.out.println(m+":"+name+":"+str);
	     }
	    //5.实例化类镜像
	      /*Student stu=(Student) clz.newInstance();*/
	     Constructor c=clz.getDeclaredConstructor(int.class,String.class,int.class);
	     Student stu=(Student)c.newInstance(1,"dd",20);
	      Field field = clz.getDeclaredField("name");
	      //第一个参数：实例化的对象
	      //第二个参数，传的值
	      //强制将私有的变量进行改变
	      field.setAccessible(true);
	      field.set(stu, "bb");
	      Method m2=clz.getDeclaredMethod("setName",String.class);
	      m2.invoke(stu, "cc");
	      //调用方法
	        //第一个参数：方法名
	        //第二个参数，参数列表所对应的数据类型String.class,int.class
	      Method m1=clz.getDeclaredMethod("getName", null);
	      //第一个参数：实例化的对象
	      //第二个参数，传的值
	       //注意调用的方法有返回值则接收，没有返回值则不需要接收数据
	       String name=(String) m1.invoke(stu, null);
	       //System.out.println(name);
	       //对于静态方法或变量可以直接传类镜像
	       Method m3=clz.getDeclaredMethod("test", null);
	       m3.invoke(stu, null);
	       m3.invoke(clz, null);
}
}

反射的步骤
1.获取类镜像
1.Class.forName(String className);
2.对象.getClass();
3.数据类型.class
2.通过类镜像获取实例（不通过new操作初始化）
Object obj=类镜像.newInstance();//默认是通过无参构造器初始化对象
3.基于类镜像去操作class对象的属性，方法，构造器
1.获取属性（属性名，修饰符，数据类型）
2.获取方法（方法名，修饰符，参数列表，返回类型）
3.获取构造器（构造器名字，修饰符，参数列表）
4.修改属性的值
5.调用方法 invoke()
6.调用指定的构造器初始化对象