在了解反射之前,先看一下java代码在计算机中经历的三个阶段:
- 第一个阶段:源代码阶段,.java文件被编译为.class文件存放在硬盘上
- 第二个阶段:Class类对象阶段,类加载器将.class文件加载到内存中,成为一个Class类的实例。Class类对象包含三个属性(对象):Field(封装属性的有关信息)、Constructor(封装构造器的有关信息)、Method(封装方法的有关信息)。
- 第三阶段:运行时阶段,通过new创建对象
Field常用的方法:
方法 | 描述 |
---|---|
getName() | 获取字段名称 |
getType() | 获取字段类型 |
setAccessible(true) | 设置属性操作 |
set(obj,value) | 为属性设置值 |
get(obj) | 获取属性值 |
Constructor常用的方法:
方法 | 描述 |
---|---|
getName() | 返回构造函数的名称 |
getParameterCount() | 返回形参的数量 |
newInstance(Object… initargs) | 使用指定的初始化参数来创建和初始化构造函数的声明类的新实例 |
Method常用的方法:
方法 | 描述 |
---|---|
getName() | 获取方法的名称 |
Object invoke(Object obj, Object … args) | 调用方法 |
反射:
将类的各个组成部分封装为其它对象,属性->Field、构造方法->Constructor、方法->Method,这就是反射机制
反射的好处:
- 可以在程序运行过程中,操作这些对象
- 可以解耦,提高程序的可扩展性
获取Class对象的方式:
- 源代码阶段获取。Class.forName(“类名”),将字节码加载进内存,返回Class对象。多用于配置文件,将类名定义在配置文件中。读取文件,加载类。
- Class类对象阶段获取。类名.class。
- 运行时阶段获取,对象.getClass(),getClass()方法在Object类中定义着
- 使用类加载器获取
// 1.源代码阶段获取,Class.forName("类名")
Class cls = Class.forName("com.szly.domain.Person");
System.out.println(cls); // class com.szly.domain.Person
// 2.Class类对象阶段获取,类名.class
Class cls2 = Person.class;
System.out.println(cls2); // class com.szly.domain.Person
// 3.运行时阶段获取,对象.getClass()
Person p = new Person();
Class cls3 = p.getClass();
System.out.println(cls3); // class com.szly.domain.Person
// 4.使用类加载器获取
ClassLoader classLoader = ReflectDemo1.class.getClassLoader();
Class cls4 = classLoader.loadClass("com.szly.domain.Person");
System.out.println(cls4); // class com.szly.domain.Person
System.out.println(cls == cls2); // true
System.out.println(cls == cls3); // true
System.out.println(cls3 == cls2); // true
System.out.println(cls == cls4); // true
注:同一个字节码文件(*.class)在一次程序运行中,只会被加载一次,不论通过哪一种方式获取的Class对象都是同一个。
Class类常用的方法:
方法 | 描述 |
---|---|
Class forName(String className) | 返回指定字符串的类关联的Class对象 |
Field[] getFields() | 获取所有public修饰的成员变量 |
Field getField(String s) | 获取指定名称的public修饰的成员变量 |
Field[] getDeclaredFields() | 获取所有的成员变量(不考虑访问修饰符) |
Field getDeclaredField(String s) | 获取指定的成员变量(不考虑访问修饰符) |
Constructor getConstructor(Class<?>… parameterTypes) | 返回一个构造函数对象 |
Constructor<?>[] getConstructors() | 返回所有的构造函数 |
T newInstance() | 通过Class类对象创建一个类的实例 |
Method getMethod(String name, Class<?>… parameterTypes) | 返回一个Method对象,该对象反映此Class对象表示的类或接口的指定公共成员方法 |
Method[] getMethods() | 获取所有public修饰的方法 |
Method getDeclaredMethod(String name, Class<?>… parameterTypes) | 获取指定的成员方法(不考虑访问修饰符) |
Method[] getDeclaredMethods() | 获取所有的成员方法(不考虑访问修饰符) |
String getName() | 以String形式返回此Class对象表示的实体名称(类,接口,数组类,原始类型或void) |
Class对象的功能:
- 获取成员变量
// 获取Class类对象
Class clazz = Class.forName("com.szly.domain.Person");
// 获取public修饰的成员变量
Field[] fields = clazz.getFields();
for(Field field : fields){
System.out.println(field);
}
Person p = new Person();
// 获取public修饰的成员变量
Field name = clazz.getField("name");
// 设置public修饰的成员变量的值
name.set(p, "tom");
// 获取public修饰的成员变量的值
System.out.println(name.get(p));
//获取所有的成员变量(包括私有的)
Field[] fieldAll = clazz.getDeclaredFields();
for(Field field : fieldAll){
System.out.println(field);
}
// 暴力反射,忽略访问权限修饰符的安全检查
// 为属性赋值前需要设置可操作,破坏了封装性可以为私有字段赋值。
fieldAll[1].setAccessible(true); // fieldAll[1]为私有属性age的Field类对象
fieldAll[1].set(p, 16);
System.out.println(fieldAll[1].get(p));
- 获取构造方法
// 获取Class对象
Class p = Person.class;
// 获取有参构造方法
Constructor c = p.getConstructor(String.class, int.class);
// 利用有参构造方法创建对象
Object obj = c.newInstance("tom", 16);
System.out.println(obj); // Person{name='tom', age=16}
// 如果使用使用空参创建对象,可以使用Class对象的newInstance()方法来简化创建对象
Object obj2 = p.newInstance();
System.out.println(obj2); // Person{name='null', age=0}
- 获取成员方法
// 获取类对象
Class clazz = Person.class;
// 获取指定指定名称的方法
Method m = clazz.getMethod("learn");
Person p1 = new Person();
// 执行实例p1的方法
m.invoke(p1);
System.out.println("-------------------------");
// 获取所有public修饰的方法,包括Object类的方法
Method[] methods = clazz.getMethods();
for (Method method : methods) {
// 获取方法名
String s = method.getName();
System.out.println(s);
}
System.out.println("-------------------------");
// 获取私有方法,并调用
Method private_method = clazz.getDeclaredMethod("identify");
// 暴力反射
private_method.setAccessible(true);
private_method.invoke(p1);
System.out.println(private_method.getName());
- 获取类名
Class<Person> clazz = Person.class;
String className = clazz.getName();
System.out.println(className); // com.szly.domain.Person
反射机制常用的一个场景:
通过配置文件动态创建类对象,并进行相应的操作。与平常使用new来创建对象相比,最大的好处就是可以动态配置一些东西,不用每一次都要在代码里面去new或者做其他的事情,以后要改的话直接改配置文件即可,代码维护起来就很方便了。再者就是有时候要适应某些需求,Java类里面不一定能直接调用相关的方法,这时候也可以通过反射机制来实现。
下面是使用反射加载配置文件,动态创建对象的一个案例:
pro.properties文件中配置以下相关类的信息:
className=com.szly.domain.Person
methodName=learn
使用反射机制创建对象并调用learn方法:
// 1. 加载配置文件
Properties prop = new Properties();
ClassLoader classLoader = ReflectTest.class.getClassLoader();
InputStream is = classLoader.getResourceAsStream("pro.properties");
prop.load(is);
// 2. 获取配置文件中的数据
String className = prop.getProperty("className");
String methodName = prop.getProperty("methodName");
// 3. 加载类进内存
Class cls = Class.forName(className);
// 4. 创建对象
Object o = cls.newInstance();
// 5. 获取方法对象
Method method = cls.getMethod(methodName);
// 6. 调用方法
method.invoke(o);
总结:
JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法,这种动态获取、调用对象方法的功能称为java语言的反射机制。