Java从入门到精通十八（反射）
反射的概念以及机制
反射机制是什么？是通过字节码文件找到其中的一个类，然后也可以找到类中的相关属性等。
我们正常一般的思维是编写java代码，然后代码会被编译为字节码文件。而我们的方法都是
自己在代码中写的，现在这个机制可以通过字节码找到代码中的属性。这就是反射机制的特
点。
一： 获取字节码文件对象的三种方式
1：通过getClass() 方法获取到Class对象。
这个方法是在Object类中的一个方法，去api查找详细的说明。
这个方法的返回类型是Object的运行时类，Object是所有类的父类。所以我们可以认为是返回一个类的对象。这个方法需要我们用实例化的对象去调用。这是基本的常识，所以我们任何情况下，想要用这个方法获取到字节码文件对象，就需要Object类的实例化对象或者继承自Object类的实例化对象。
2：通过类名.class获取到Class对象
似乎这种是一种更加简单的方式。
Class<Refelct_demo01> re_1 = Refelct_demo01.class;
- 1
3：通过Class.forName()获取到Class对象
根据api的说明举例就很容易明白了。
Class 提供了两个这样的重载方法。
注意返回是一个static修饰的类对象。
简单举例一下使用
Class<?> aClass = Class.forName("java_practice.Student");
- 1
三种获取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();
- 1
但是反射是什么？我们先通过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)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
获取构造器数组对象
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
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
在获取到构造器之后呢，我们可以利用得到的构造器对象创建实例对象。
举个·例子，通过无参构造器来创建一个实例对象/类对象
三： 获取一般方法和成员变量
同样可以获取到方法和成员变量
1：获取一般方法（成员方法）
首先，我们还是可以先获取到Class对象，然后获取成员方法
api提供了两个获取一般方法的方法
同样一个是返回指定的方法对象，一个是返回一个数组
//获取单个方法公共的方法对象
Method m = aClass.getMethod("getName");
//获取到成员方法对象(包括了继承的方法)
Method[] methods = aClass.getMethods();
for(Method method:methods)
{
System.out.println(method);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
但是这样获取的一般只是公共的方法，私有化的方法是获取不到的。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 );
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
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);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
三： 使用类属性
我们已经了解到如何获取到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);//调用实例化对象下的指定方法
- 1
- 2
- 3
- 4
- 5
注意对私有方法的调用的时候，还需要进行跳过访问检查，才可以调用到。具体参考。
Constructor<?> con = aClass.getConstructor();//获取获取构造器
Object o = con.newInstance();//获取实例化对象
Method kk = aClass.getDeclaredMethod("kk");//kk是私有化的
kk.setAccessible(true);//跳过访问检查
kk.invoke(o);
- 1
- 2
- 3
- 4
- 5
2： 给成员变量赋值
Field field = aClass.getField("say");
//获取无参构造方法创建对象
Constructor<?> con = aClass.getConstructor();
Object obj = con.newInstance();
field.set(obj,"hello");//给obj的成员变量say 赋值
- 1
- 2
- 3
- 4
- 5
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);//获取到成员变量的值
- 1
- 2
- 3
- 4
- 5
- 6
私有化的成员变量的一样要越过访问检查
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);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
四： 反射越过泛型检查
这样的特点如何体现？
如果我定义一个集合，集合中的泛型是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);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
有没有觉得很有逼数。
五： 反射运行配置文件指定内容
创建两个类
package reflect_demo;
public class Teacher666 {
public void teach()
{
System.out.println("love students");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
package reflect_demo;
public class Student666 {
public void study()
{
System.out.println("study hard");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
给一个简单的配置文件Class.txt
className = reflect_demo.Student666
methodName = study
- 1
- 2
然后测试类·
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);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
这样做的好处是，在我想要在该类指定运行对象的时候，我不需要在该类中进行指定类，或者像之前一样进行new对象，我想要运行对象的哪个方法，就直接在配置文件中进行简单修改就可以了。这里就体现了反射的这方面的特点。简单演示一下。反射是非常重要的一个知识点。在Spring中就会有用到反射的知识点，所以感觉基础扎实点会比较好，如果不是理解的就去用的话，很容易陷入迷茫，并且效率很低。
反射的优点，我们上面的简单说明体现了一部分。缺点在于动态解析这些方面，以及安全等等。其实你从代码上可以看的出来，从字节码进行找到这个类，然后获取相关的属性等等，这样其实是比较麻烦的，浪费效率，另外代码是无法和常规编程一样进行优化。反射可以做到一些我们常规方式下五发进行的操作，所以会存在安全的隐患。这样的实现很明显会破坏掉类的封装性等等。
但是我们会用到它，在工厂模式下会有非常大的用处。感觉有趣。
文章来源: daodaozi.blog.csdn.net，作者：兰舟千帆，版权归原作者所有，如需转载，请联系作者。
原文链接：daodaozi.blog.csdn.net/article/details/123793027
- 点赞
- 收藏
- 关注作者
评论（0）