反射的概念以及机制
反射机制是什么？是通过字节码文件找到其中的一个类，然后也可以找到类中的相关属性等。
我们正常一般的思维是编写java代码，然后代码会被编译为字节码文件。而我们的方法都是自己在代码中写的，现在这个机制可以通过字节码找到代码中的属性。这就是反射机制的特点。
一： 获取字节码文件对象的三种方式
1：通过getClass() 方法获取到Class对象。
这个方法是在Object类中的一个方法，去api查找详细的说明。
这个方法的返回类型是Object的运行时类，Object是所有类的父类。所以我们可以认为是返回一个类的对象。这个方法需要我们用实例化的对象去调用。这是基本的常识，所以我们任何情况下，想要用这个方法获取到字节码文件对象，就需要Object类的实例化对象或者继承自Object类的实例化对象。
2：通过类名.class获取到Class对象
似乎这种是一种更加简单的方式。
Class<Refelct_demo01> re_1 = Refelct_demo01.class;
3：通过Class.forName()获取到Class对象
根据api的说明举例就很容易明白了。
Class 提供了两个这样的重载方法。
注意返回是一个static修饰的类对象。
简单举例一下使用
Class<?> aClass = Class.forName("java_practice.Student");
三种获取Class 对象的区别（该段在语雀的公开文档引用）
getClass() 接在对象的后面。getClass() 是 Object 类中的方法，而 Object 类是所有 Java 类的父类。
.class 接在任意一个 Class 类的后面，在编译期加载（静态加载）。
Class.forName 是 Class 类中的一个静态方法，从指定的 classloader 中装载类，返回与给定字符串对应类或接口的 Class 对象，在运行期加载（动态加载）。
关于静态加载和动态加载：
静态加载的类的源程序在编译时期加载（必须存在），而动态加载的类在编译时期可以缺席（源程序不存在时编译器也不会报错）。
当类找不到的时候，静态加载方式会抛出异常"NoClassDefFoundError"，而动态加载方式则抛出"ClassNotFoundException"异常。
Class.forName() 和 ClassLoader 的 loadClass() 之间的区别：
Class.forName() 加载类是将类进了初始化，而 ClassLoader 的 loadClass() 方法并没有对类进行初始化，只是把类加载到了虚拟机中。
Spring 框架中 IOC 容器的实现就是使用的 ClassLoader 的 loadClass() 方法。
而在我们使用 JDBC 时通常是使用 Class.forName() 方法来加载数据库连接驱动。这是因为在 JDBC 规范中明确要求 Driver (数据库驱动)类必须向 DriverManager 注册自己。
二 ： 实例化
我们要通过反射的方式进行实例化
现在想想，如果不用反射的话，我们怎么样实例化对象？通过new进行实例化。
Refelct_demo01 re = new Refelct_demo01();
但是反射是什么？我们先通过Class对象获得构造器。为什么要这样做？你可以理解为它是倒着来的。
我们正常的是有i了构造器，然后实例化。现在我们这样去做。
构造器的获取在Class类中一个给了两个，一个是指定构造器，一个是返回一个数组。我们来看。
注意这两个只能拿到public修饰的构造器，要想拿到全部。我们可以用
举例子
指定构造器
Class<?> aClass = Class.forName("java_practice.Student"); //基本数据类型也可以通过.class 得到对应的Class 类型 Constructor<?> con = aClass.getConstructor(int.class, String.class); //填入指定构造方法中的类型.class即可 System.out.println(con);//public java_practice.Student(int,java.lang.String) //可获取到私有构造方法 Constructor<?> dd = aClass.getDeclaredConstructor(String.class); System.out.println(dd);//private java_practice.Student(java.lang.String)
获取构造器数组对象
Class<?> aClass = Class.forName("java_practice.Student"); Constructor<?>[] cons = aClass.getConstructors();//拿到public类型的构造方法 for(Constructor con : cons) { System.out.println(con); } Constructor<?>[] dc = aClass.getDeclaredConstructors();//拿到所有的构造方法 for(Constructor dcc: dc) { System.out.println( dcc); }
在获取到构造器之后呢，我们可以利用得到的构造器对象创建实例对象。
举个·例子，通过无参构造器来创建一个实例对象/类对象
三： 获取一般方法和成员变量
同样可以获取到方法和成员变量
1：获取一般方法（成员方法）
首先，我们还是可以先获取到Class对象，然后获取成员方法
api提供了两个获取一般方法的方法
同样一个是返回指定的方法对象，一个是返回一个数组
//获取单个方法公共的方法对象 Method m = aClass.getMethod("getName"); //获取到成员方法对象(包括了继承的方法) Method[] methods = aClass.getMethods(); for(Method method:methods) { System.out.println(method); }
但是这样获取的一般只是公共的方法，私有化的方法是获取不到的。Class 类也提供了获取所有的方法包括私有方法的方法。
Method speak__ = aClass.getDeclaredMethod("speak__");//static 修饰的方法 Method kk = aClass.getDeclaredMethod("kk");//kk是私有化方法 Method[] mm = aClass.getDeclaredMethods(); for(Method m : mm) { System.out.println(m ); }
2： 获取到成员变量
与此相关的Class提供的方法
Field field = aClass.getField("say");//public类型的 Field[] fields = aClass.getFields(); for(Field f : fields) { System.out.println(f); } Field name = aClass.getDeclaredField("name");//name是私有的 Field[] ff = aClass.getDeclaredFields(); for(Field f : ff) { System.out.println(f); }
三： 使用类属性
我们已经了解到如何获取到Class对象，构造器，方法，局部变量。那么我们如果去调用一个方法或者如何去给一个类的成员变量赋值？
1： 实现方法的调用
正常情况下，如果不是用到反射进行编程的话，我们可以用实例对象去调用一个方法。现在我们也实现实例方法对方法的人调用，只不过方式是不一样的。感受一下。
Class<?> aClass = Class.forName("java_practice.Student");//获取到Class 对象 Constructor<?> con = aClass.getConstructor();//获取获取构造器 Object o = con.newInstance();//获取实例化对象 Method m = aClass.getMethod("speak");//获取指定的方法对象 m.invoke(o);//调用实例化对象下的指定方法
注意对私有方法的调用的时候，还需要进行跳过访问检查，才可以调用到。具体参考。
Constructor<?> con = aClass.getConstructor();//获取获取构造器 Object o = con.newInstance();//获取实例化对象 Method kk = aClass.getDeclaredMethod("kk");//kk是私有化的 kk.setAccessible(true);//跳过访问检查 kk.invoke(o);
2： 给成员变量赋值
Field field = aClass.getField("say"); //获取无参构造方法创建对象 Constructor<?> con = aClass.getConstructor(); Object obj = con.newInstance(); field.set(obj,"hello");//给obj的成员变量say 赋值
Field field = aClass.getField("say");//获取成员变量对象 Constructor<?> con = aClass.getConstructor();//获取构造器 Object obj = con.newInstance();//获取类实例对象 field.set(obj,"hello");//给obj的成员变量say 赋值 Object o = field.get(obj);//获取obj对象下的成员say的对象 System.out.println(o);//获取到成员变量的值
私有化的成员变量的一样要越过访问检查
Field name = aClass.getDeclaredField("name"); Constructor<?> con_ = aClass.getConstructor(); Object o1 = con_.newInstance(); name.setAccessible(true); name.set(o1,"jgdabc"); Object o = name.get(o1); System.out.println(o);
四： 反射越过泛型检查
这样的特点如何体现？
如果我定义一个集合，集合中的泛型是Integer的，我现在要给这个集合存放一个String类型的数据。
可以吗？用2反射的这个机制就可以实现。
package reflect_demo; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.ArrayList; //实现ArrayList<Integer>集合，给利用反射的特点给集合当中添加字符串数据 public class ReflectDemo08 { public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { ArrayList<Integer> array = new ArrayList<Integer>(); array.add(1); // 通过反射实现正常情况下，无法实现的操作 Class<? extends ArrayList> arr_cla = array.getClass();//还是获取到Class对象 Method m = arr_cla.getMethod("add", Object.class);//调用到add方法,可以知道这个是Object类型的方法 m.invoke(array, "hello"); //给array对象下的m里面的add方法传入值 //反射可以越过泛型检查的，获取到原始的参数所需要的参数类型 System.out.println(array); } }
有没有觉得很有逼数。
五： 反射运行配置文件指定内容
创建两个类
package reflect_demo; public class Teacher666 { public void teach() { System.out.println("love students"); } }
package reflect_demo; public class Student666 { public void study() { System.out.println("study hard"); } }
给一个简单的配置文件Class.txt
className = reflect_demo.Student666 methodName = study
然后测试类·
package reflect_demo; //通过配置文件运行类中的方法 import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Properties; public class ReflectDemo09 { public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException { //加载数据 Properties prop = new Properties(); FileReader fileReader = new FileReader("E:\\java_doc\\src\\reflect_demo\\class.txt"); prop.load(fileReader); fileReader.close(); String className = prop.getProperty("className");//相当于根据键获取到值。 String methodName = prop.getProperty("methodName"); //通过反射来使用 Class<?> c = Class.forName(className); Constructor<?> con = c.getConstructor(); Object o = con.newInstance(); Method m = c.getMethod(methodName); m.invoke(o); } }
这样做的好处是，在我想要在该类指定运行对象的时候，我不需要在该类中进行指定类，或者像之前一样进行new对象，我想要运行对象的哪个方法，就直接在配置文件中进行简单修改就可以了。这里就体现了反射的这方面的特点。简单演示一下。反射是非常重要的一个知识点。在Spring中就会有用到反射的知识点，所以感觉基础扎实点会比较好，如果不是理解的就去用的话，很容易陷入迷茫，并且效率很低。
反射的优点，我们上面的简单说明体现了一部分。缺点在于动态解析这些方面，以及安全等等。其实你从代码上可以看的出来，从字节码进行找到这个类，然后获取相关的属性等等，这样其实是比较麻烦的，浪费效率，另外代码是无法和常规编程一样进行优化。反射可以做到一些我们常规方式下五发进行的操作，所以会存在安全的隐患。这样的实现很明显会破坏掉类的封装性等等。
但是我们会用到它，在工厂模式下会有非常大的用处。感觉有趣。
