运行java代码要经历的三个阶段
反射，程序框架设计的灵魂，将类的各个组成部分封装成其他对象，这就是反射机制。
框架：半成品的软件，在框架的基础上进行开发，可以简化编码
反射的好处：
- 可以在程序运行的过程中，操作这些对象
- 可以解耦，提高程序的可拓展性
在运行状态中：
- 对于任意一个类，都能够知道这个类的所有属性和方法
- 对于任意一个对象，都能够调用它的任意属性和方法
与反射机制相关的类
- Java.lang.class :代表整个类编译得到的class文件（字节码）
- Java.lang.reflect.Method ：代表字节码中的方法字节码
- Java.lang.reflect.Constructor ：代表字节码中的构造器字节码
- Java.lang.reflect.Field ：代表字节码中的属性字节码
要操作一个字节码，首先要得到这个类的字节码，下面是三种得到字节码的方式
static Class.forName(String className) 这里的className需要时类的全路径，这是一个静态方法
public class reflect1 {public static void main(String[] args) throws ClassNotFoundException {//第一种方式Class c1=Class.forName("java.lang.String");System.out.println(c1);} }java中的任意一个对象.getClass() ，这个方法继承自Object
public class reflect1 {public static void main(String[] args) throws ClassNotFoundException {//第一种方式Class c1=Class.forName("java.lang.String");System.out.println(c1);//第二种方式String s="hello";Class c2=s.getClass();System.out.println(c2);} }java语言中的任意一种类型，包括基本数据类型，都有.class属性。
public class reflect1 {public static void main(String[] args) throws ClassNotFoundException {//第一种方式Class c1=Class.forName("java.lang.String");System.out.println(c1);//第二种方式String s="hello";Class c2=s.getClass();System.out.println(c2);//第三种方式Class c3=String.class;System.out.println(c3);} }JVM在加载一个类的时候，会把这个类的.class字节码文件放在方法区中，栈中放入main方法进行压栈，堆中new出对象c，但是无论使用什么方法获取字节码，一样的class字节码文件只会放一份在方法区中，得到的c变量都是指向方法区中的同一份.class文件。
使用反射机制来实例化对象
通过Class的newInstance() 方法可以实例化对象
但是newInstance()方法内部实际上调用了无参构造方法，必须要保证无参构造的存在才可以
private static void test2() throws InstantiationException, IllegalAccessException {Object o=Student.class.newInstance();System.out.println(o);}
反射机制的灵活性，在不修改源码的情况下，可以做到不同对象的实例化，符合OCP开闭原则：对拓展开放，对修改关闭.
- 下面的代码中首先利用FileReader读取配置文件，配置文件里面保存了键和值，值是类名，之后new了一个Properties对象，Properties对象的键和值都是String类型，是一种Map数据类型，之后将文件流对象传入Properties对象，再根据键得到值，然后利用反射机制传入类名新建一个对象，实现了对象的灵活创建。
private static void test3() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {FileReader fr=new FileReader("Student.properties");Properties pro=new Properties();pro.load(fr);fr.close();String forName=pro.getProperty("Student");Class C=Class.forName(forName);Object o=C.newInstance();System.out.println(o);}如果只想要让类里面的某些代码被执行，那么可以使用静态代码和Class.forName,像下面的代码那样，每次类加载器加载一个类的时候，就会先执行静态代码块，使用Class.forName而不用创建类的实例化变量
public class reflect1 {static {System.out.println("静态代码执行！");} }private static void test4() {try {Class.forName("reflect1");} catch (ClassNotFoundException e) {throw new RuntimeException(e);}}获取文件的类路径，可以通过类加载器获取，具体如下：
private static void test4() {String path=Thread.currentThread().getContextClassLoader().getResource("a.txt").getPath();System.out.println(path);}资源绑定器
用来获取属性配置文件中的内容
属性配置文件必须要放在类路径下(src下面)
必须是properties后缀
绑定某个属性配置文件的时候，只需要填写配置文件的名字，不需要写后缀，也不能写后缀
private static void test4() {ResourceBundle bundle=ResourceBundle.getBundle("Student");String path=bundle.getString("Student");System.out.println(path);}获取并操作属性字节码
首先获取整个字节码
利用字节码的getFields可以获取到public修饰的所有属性
利用字节码的getDeclaredFields可以获取到所有属性，无论什么修饰符都可以获取到
遍历属性列表
通过属性.getName()可以获取到属性的名字
通过属性.getType()可以获取到属性的完整类型，getSimpleName是获取简化的类名
通过属性.getModifiers()可以获取到属性的修饰符id，通过Modifier.toString(id)就可以拿到完整的修饰符
import java.io.Serializable;public class Student implements Serializable { // 属性设置为privateprivate String name;private int age;private static String room;//无参数构造public Student() {}//有参数构造public Student(String name, int age, String room) {this.name = name;this.age = age;this.room=room;}//getter方法public String getName() {return name;}public int getAge() {return age;}public static String getRoom() {return room;}//setter方法public void setName(String name) {this.name = name;}public void setAge(int age) {this.age = age;}public static void setRoom(String room) {Student.room = room;}//重写equals方法public boolean equals(Object obj){if(obj instanceof Student) {//首先将得到的Object转为Student，否则使用不了Student特有的方法（多态的弊端）Student t = (Student) obj;return t.getAge() == this.getAge() && t.getName() == this.getName() && t.getRoom() == this.getRoom();}return false;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';} }private static void test5() throws ClassNotFoundException {//获取整个类Class studentClass=Student.class;//获取public修饰的属性,一个Filed包括private static String room;Field[] fileds=studentClass.getFields();for (Field filed : fileds) {System.out.println(filed);}//获取所有的属性,一个Filed包括private static String room;fileds=studentClass.getDeclaredFields();for (Field filed : fileds) {//获取属性的名字System.out.println("属性的名字:");System.out.println(filed.getName());//获取属性的类型Class filedTypeClass=filed.getType();//getName是获取完整类型，getSimpleName是获取简化的类名String filedType=filedTypeClass.getSimpleName();System.out.println("属性的类型");System.out.println(filedType);//获取属性的修饰符int modify=filed.getModifiers();String modifyName= Modifier.toString(modify);System.out.println("属性的修饰符");System.out.println(modifyName);System.out.println("==================");}}利用反射机制访问一个对象的属性
要使用反射，当然要先获取一个类的字节码文件
利用获取到的字节码文件，再用newInstance方法创建一个对象（使用反射的类必须有无参构造）
利用字节码文件获取这个类的某个属性
利用这个属性给创建的对象的对应的属性赋值
在设置对象的属性值之前，需要在使用
set方法之前，调用setAccessible(true)方法来取消对字段的访问权限检查。否则， 会报IllegalAccessException异常。这是因为name字段被声明为private，无法直接访问。但是使用反射机制绕过访问权限限制可能会导致安全问题。private static void test6() throws NoSuchFieldException, InstantiationException, IllegalAccessException {//获取整个类Class studentClass=Student.class;Field filed=studentClass.getDeclaredField("name");Object obj=studentClass.newInstance();filed.setAccessible(true); // 取消对字段的访问权限检查filed.set(obj,"zs");System.out.println(obj);}利用反射机制获取Method
获取整个类的字节码文件
通过字节码文件得到方法的字节码，并且遍历它
通过.getName()获取方法名字
通过.getReturnType().getSimpleName()获取返回值类型
通过.getModifiers()获取修饰符id，然后通过Modifier.toString(id)得到修饰符
通过.getParameterTypes()得到修饰符列表，遍历这个列表，通过.getSimpleName()得到参数名称
private static void test7() {Class studentClass=Student.class;Method[] methods=studentClass.getDeclaredMethods();for (Method method : methods) {//获取方法名System.out.println("方法名");System.out.println(method.getName());//获取方法的返回值类型System.out.println("方法的返回值类型");System.out.println(method.getReturnType().getSimpleName());//获取修饰符列表System.out.println("方法的修饰符列表");System.out.println(Modifier.toString(method.getModifiers()));//方法的参数列表System.out.println("方法的参数列表");Class[] parametorType= method.getParameterTypes();for (Class aClass : parametorType) {System.out.println(aClass.getSimpleName());}System.out.println("========================");}}通过反射机制操纵Method
首先获取字节码
利用得到的字节码新建一个对象
利用得到的字节码获取一个指定的方法，在java里面，由于存在方法的重载，所以区分一个方法是由方法名+方法参数类型，而不仅仅是方法名，所以使用getDeclaredMethod方法需要一个方法名和若干参数的class
最后使用这个方法的invoke方法，传入要操纵的对象和实参
private static void test8() throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {Class studentClass=Student.class;Object obj=studentClass.newInstance();Method setName=studentClass.getDeclaredMethod("setName",String.class);Object returnVa=setName.invoke(obj,"zs");System.out.println(obj);}通过反射机制获取构造方法
获取整个类的字节码文件
通过字节码文件得到构造方法的字节码，并且遍历它
通过.getName()获取方法名字
通过.getModifiers()获取修饰符id，然后通过Modifier.toString(id)得到修饰符
通过.getParameterTypes()得到修饰符列表，遍历这个列表，通过.getSimpleName()得到参数名称
private static void test9() {Class studentClass=Student.class;Constructor[] constructors=studentClass.getDeclaredConstructors();for (Constructor constructor : constructors) {//获取构造方法名System.out.println("构造方法名");System.out.println(constructor.getName());//获取修饰符列表System.out.println("构造方法的修饰符列表");System.out.println(Modifier.toString(constructor.getModifiers()));//方法的参数列表System.out.println("构造方法的参数列表");Class[] parametorType= constructor.getParameterTypes();for (Class aClass : parametorType) {System.out.println(aClass.getSimpleName());}System.out.println("========================");}}使用反射机制的构造方法创建对象
直接利用字节码创建（已过时）
首先获取无参构造函数，然后调用无参构造函数
首先获取有参构造函数，然后调用有参构造函数
private static void test10() throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {//使用反射创建对象//1. 直接利用字节码创建Class studentClass=Student.class;Object t1=studentClass.newInstance();//2. 先利用字节码获取构造函数，然后再利用构造函数创建对象//首先是无参构造Constructor con1=studentClass.getDeclaredConstructor();Object t2=con1.newInstance();//最后是有参构造方法Constructor con2=studentClass.getDeclaredConstructor(String.class,int.class,String.class);Object t3=con2.newInstance("zs",18,"h111");System.out.println(t1);System.out.println(t2);System.out.println(t3);}使用反射获取一个类的父类以及接口
private static void test11() {Class stringClass=String.class;//获取String的父类Class superClass=stringClass.getSuperclass();System.out.println("父类是");System.out.println(superClass.getSimpleName());//获取接口Class[] interface1=stringClass.getInterfaces();System.out.println("接口是");for (Class aClass : interface1) {System.out.println(aClass.getSimpleName());}}
