什么是反射?
(1)Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息,从而操作类或对象的属性和方法。 本质是JVM得到class对象之后,再通过class对象进行反编译,从而获取对象的各种信息。
(2)Java属于先编译再运行的语言,程序中对象的类型在编译期就确定下来了, 而当程序在运行时可能需要动态加载某些类,这些类因为之前用不到, 所以没有被加载到JVM。通过反射,可以在运行时动态地创建对象并调用其属性, 不需要提前在编译期知道运行的对象是谁。
简单说就是能够分析类信息的能力的程序叫做反射(类信息指的就是比如属性、方法、构造器等)
举一个实际的例子,在servlet框架当中我们写过JBDC类,在这个类当中我们引入了一个mysql.jar包,那么这个jar包是怎么起作用的呢,而servlet类当中没有main方法,让servlet类启动,加载到JVM当中就用到了反射
反射是如何工作的,要想理解反射是如何工作的先了解下类的生命周期
反射的好处 :
1.在程序的运行过程中,来操作这些对象
2.可以解耦,提高程序的可扩转性
获取class对象的方式
1.Class.forName("全类名"):将字节码文件加载进内存,返回class对象(多用于配置文件,将类名定义在配置文件当中,读取文件,加载类)
2.类名.class:通过类名的class获取 (多用于参数传递)
3.对象.getClass(): getClass()方法在object类当中定义着 (多用于对象获取字节码的方式)
上代码
首先定义一个person类,内部定义好成员变量,构造方法和成员方法
public class Person {
private String nameString;
private int age;
public Person() {
}
public Person(String nameString, int age) {
this.nameString = nameString;
this.age = age;
}
public String getNameString() {
return nameString;
}
public void setNameString(String nameString) {
this.nameString = nameString;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [nameString=" + nameString + ", age=" + age + "]";
}
}
定义测试类
public class refulectDemo1 {
/**
* 1.Class.forName("全类名"):将字节码文件加载进内存,返回class对象
2.类名.class:通过类名的class获取
3.对象.getClass(): getClass()方法在object类当中定义着
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws Exception {
// 1.Class.forName("全类名"):
Class class1 = Class.forName("reflect.Person");
System.out.println(class1);
//2.类名.class:通过类名的class获取
Class class2 = Person.class;
System.out.println(class2);
//3.对象.getClass()
Person person = new Person();
Class class3 = person.getClass();
System.out.println(class3);
}
}
用 == 比较
System.out.println(class1 == class2);
System.out.println(class2 == class3);
//输出
true
true
同一类加载器加载的文件(*.class)在一次程序运行过程中,只会被加载一次,不论你通过那种方式获取的class对象都是同一个
class对象功能
获取成员变量
1.Field[] getFields() :获取所有public修饰的成员变量
2.Field getField(String name):获取指定名称的
3.Field[] getDeclaredFilds():获取所有的成员变量,不考虑修饰符
4.Field getDeclaredField(String name)
获取构造方法
1.Constructor[] getConstructors()
2.Constructor getConstructor(类...parameterTypes)
3.Constructor[] getDeclaredConstructors()
4.Constructor getDeclaredConstructors(类...parameterTypes)
获取方法名
1.Method[] getMethod()
2.Method getMethod(String name,类... parameterTypes)
3.Method[] getDeclaredMethod()
4.Method getDeclaredMethod(String name,类... parameterTypes)
获取类名
String getName()
Field成员变量
1.设置值
void set(Object obj,Object value)
2.获取值
get(Object obj)
3.忽略安全访问修饰符的安全检查
setAccessible(true) //暴力反射 ---》private
public static void main(String[] args) throws Exception {
//0.获取Person的Class对象
Class personClass = Person.class;
/*
1. 获取成员变量们
* Field[] getFields()
* Field getField(String name)
* Field[] getDeclaredFields()
* Field getDeclaredField(String name)
*/
//1.Field[] getFields()获取所有public修饰的成员变量
Field[] fields = personClass.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("------------");
//2.Field getField(String name)
Field a = personClass.getField("a");
//获取成员变量a 的值
Person p = new Person();
Object value = a.get(p);
System.out.println(value);
//设置a的值
a.set(p,"张三");
System.out.println(p);
System.out.println("===================");
//Field[] getDeclaredFields():获取所有的成员变量,不考虑修饰符
Field[] declaredFields = personClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
//Field getDeclaredField(String name)
Field d = personClass.getDeclaredField("d");
//忽略访问权限修饰符的安全检查
d.setAccessible(true);//暴力反射
Object value2 = d.get(p);
System.out.println(value2);
}
Constructor访问构造方法
创建对象
T newInstance(Object... initarges)
如果使用空参数构造方法,此操作可以简化:class对象的newInstance方法
public static void main(String[] args) throws Exception {
//0.获取Person的class对象
Class personClass = Person.class;
//因为构造器的方法名称是相同的,不同的是参数列表,所以我们可以根据不同的参数列表来找到构造器
Constructor constructor = personClass.getConstructor(String.class,int.class);
System.out.println(constructor);
//创建对象
Object perObject = constructor.newInstance("张三",20);
System.out.println(perObject);
System.out.println("-------------------------------");
Constructor constructor1 = personClass.getConstructor();
System.out.println(constructor1);
//创建对象
Object perObject1 = constructor1.newInstance();
System.out.println(perObject1);
System.out.println("-------------------------------");
Object o = personClass.newInstance();
System.out.println(o);
}
Method:方法对象
执行方法
object invoke(Object object,Object... ages)
获取方法名称
String getName:获取方法名
public static void main(String[] args) throws Exception {
//0.获取Person的class对象
Class personClass = Person.class;
//获取指定名称的方法,方法无参
Method eat_method = personClass.getMethod("eat");
//执行方法
Person person =new Person();
eat_method.invoke(person);
//获取指定名称的方法,方法有参
Method eat_method1 = personClass.getMethod("eat",String.class);
//执行方法
eat_method1.invoke(person,"饭");
//获取所有public修饰的方法
Method[] methods = personClass.getMethods();
for (Method method : methods) {
System.out.println(method);
//获取方法的名称
String name = method.getName();
System.out.println(name);
}
}