1、反射的概念
反射是框架设计的灵魂。
框架:半成品软件。可以在框架的基础上进行软件开发,简化编码。
使用框架并不需要使用反射。但是写框架的时候是需要反射的。
将类的各个组成部分封装为其他对象,这就是反射。
2、Java代码在计算机中经历的阶段:三个阶段
第一阶段:Source源代码阶段
Person.java
public class Person{
private String name;
private int age;
public Person(){}
public void eat(){}
}
编译:javac 编译,编译完生成Person.class字节码文件
Person.class中包含三部分:
a. private String name;
private int age;
b. public Person(){}
c. public void eat(){}
第二阶段:Class类对象阶段。
类加载器ClassLoader,可以把Person.class加载到内存中,加载到内存后有对应的Class类对象
成员变量,封装为Field对象。会有多个成员变量,用Field[] fields;
构造方法,封装为Constructor对象。可能有多个构造方法,用Constructor[] cons;
成员方法,封装为Method对象。有多个成员方法,用Method[] methods。
将来可以通过Class类对象的行为来创建真正的Person等对象。
第三阶段:Runtime运行时阶段。
Person对象
new Person();
3、反射的好处
a. 可以在程序运行过程中,操作这些对象。
b. 可以解耦,提高程序的可扩展性。
4、获取Class类对象的方式
- 将字节码文件加载进内存,返回Class对象。多用于配置文件,将类名定义在配置文件中。读取文件,加载类。
Java代码在第一个阶段,也就是只有.class字节码文件并没有进内存。需要手动将.class加载进内存,通过
Class.forName("全类名");
- 已经加载进内存了,可通过类名的属性class获取Class对象。多用于参数的传递。
类名.class
- 已经有对象了,通过getClass()方法(在Object类中定义着)获取Class对象,多用于对象的获取字节码的方式。
对象.getClass()
package com.itheima.day01.reflect;
public class Person {
private String name;
private int age;
//快速创建构造方法及getter\setter\toString(),Alt+Insert
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.itheima.day01.reflect;
public class ReflectDemo1 {
/**
获取Class对象的方式:
1. Class.forName("全类名"):将字节码文件加载进内存,返回Class对象
2. 类名.class:通过类名的属性class获取
3. 对象.getClass():getClass()方法在Object类中定义着。
*/
public static void main(String[] args) throws ClassNotFoundException {
//Person.java保存后自动编译为Person.class
//1. Class.forName("全类名")
Class cls1 = Class.forName("com.itheima.day01.reflect.Person");
System.out.println(cls1);//class com.itheima.day01.reflect.Person
// 2. 类名.class
Class cls2 = Person.class;
System.out.println(cls2);//class com.itheima.day01.reflect.Person
//3. 对象.getClass()
Person p = new Person();
Class cls3 = p.getClass();
System.out.println(cls3);//class com.itheima.day01.reflect.Person
//==比较三个对象
System.out.println(cls1== cls2);//true
System.out.println(cls1==cls3);//true
}
}
结论:同一个字节码文件(*.class)在一次程序运行过程中,只会被加载一次,不论通过哪一种方式获取的Class对象都是同一个。
5、Class对象功能
- 获取成员变量们
Field[] getFields():获取所有公共的成员变量
Field getField(String name):获取指定名称的公共成员变量
Field[] getDeclaredFields():获取所有的成员变量
Field getDeclaredField(String name):获取单个成员变量
- 获取构造方法们
Constructor<?>[] getConstructors():获取所有公共的构造方法
Constructor<T> getConstructor(类<?>... parameterTypes):获取指定的公共构造方法
Constructor<?>[] getDeclaredConstructors():获取所有的构造方法
Constructor<T> getDeclaredConstructor(类<?>... parameterTypes):获取单个构造方法
- 获取成员方法们
Method[] getMethods():获取所有的公共成员方法,包括Object的方法
Method getMethod(String name, 类<?>... parameterTypes):获取指定名称的公共成员方法
Method[] getDeclaredMethods():获取所有的成员方法
Method getDeclaredMethod(String name, 类<?>... parameterTypes):获取单个成员方法
- 获取类名
String getName():获取类名
String getPackage():获取此类的包
6、使用Class对象功能
- Field:成员变量
操作:
1、设置值:void set(Object obj, Object value)
2、获取值:Object get(Object obj)
3、忽略访问权限修饰符的安全检查:setAccessible(true)暴力反射
package com.itheima.day01.reflect;
public class Person {
private String name;
private int age;
public String a;
protected String b;
String c;
private String d;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", a='" + a + '\'' +
", b='" + b + '\'' +
", c='" + c + '\'' +
", d='" + d + '\'' +
'}';
}
}
package com.itheima.day01.reflect;
import java.lang.reflect.Field;
public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
//0.获取Person的Class对象
Class personClass = Person.class;
Field[] fields= personClass.getFields();
for(Field field: fields){
//public java.lang.String com.itheima.day01.reflect.Person.a
System.out.println(field);
}
System.out.println("-------------");
Field a= personClass.getField("a");
//获取成员变量a的值
Person p = new Person();
Object value = a.get(p);
System.out.println(value);//null
a.set(p,"abc");
System.out.println(p);//Person{name='null', age=0, a='abc', b='null', c='null', d='null'}
System.out.println("==================");
Field[] declaredFields = personClass.getDeclaredFields();
for(Field field: declaredFields){
// private java.lang.String com.itheima.day01.reflect.Person.name
// private int com.itheima.day01.reflect.Person.age
// public java.lang.String com.itheima.day01.reflect.Person.a
// protected java.lang.String com.itheima.day01.reflect.Person.b
// java.lang.String com.itheima.day01.reflect.Person.c
// private java.lang.String com.itheima.day01.reflect.Person.d
System.out.println(field);
}
Field d = personClass.getDeclaredField("d");
//忽略访问权限修饰符的安全检查
d.setAccessible(true);//暴力反射
Object value2 = d.get(p);
System.out.println(value2);//null
}
}
- Constructor:构造方法
构造方法用来创建对象
1、创建对象:T newInstance(Object... initargs)
2、如果使用空参数构造方法创建对象,操作可以简化:Class对象的newInstance()方法
3、忽略访问权限修饰符的安全检查:setAccessible(true)暴力反射
package com.itheima.day01.reflect;
import java.lang.reflect.Constructor;
public class ReflectDemo3 {
public static void main(String[] args) throws Exception {
//0.获取Person的Class对象
Class personClass = Person.class;
Constructor[] constructors = personClass.getConstructors();
for(Constructor constructor:constructors){
// public com.itheima.day01.reflect.Person()
// public com.itheima.day01.reflect.Person(java.lang.String,int)
System.out.println(constructor);
}
Constructor constructor = personClass.getConstructor(String.class,int.class);
//public com.itheima.day01.reflect.Person(java.lang.String,int)
System.out.println(constructor);
//创建对象
Object person = constructor.newInstance("ab",23);
//Person{name='ab', age=23, a='null', b='null', c='null', d='null'}
System.out.println(person);
System.out.println("-----------------");
Constructor constructor1 = personClass.getConstructor();
//public com.itheima.day01.reflect.Person()
System.out.println(constructor1);
//创建对象
Object person1 = constructor1.newInstance();
//Person{name='null', age=0, a='null', b='null', c='null', d='null'}
System.out.println(person1);
//如果使用空参数构造方法创建对象,操作可以简化:Class对象的newInstance方法
Object person2 = personClass.newInstance();
//Person{name='null', age=0, a='null', b='null', c='null', d='null'}
System.out.println(person2);
constructor.setAccessible(true);
}
}
- Method:成员方法
操作:
1、执行方法:Object invoke(Object obj, Object... args)
2、忽略访问权限修饰符的安全检查:setAccessible(true)暴力反射
3、获取方法名称:String getName()
package com.itheima.day01.reflect;
public class Person {
private String name;
private int age;
public String a;
protected String b;
String c;
private String d;
//快速创建构造方法及getter\setter\toString(),Alt+Insert
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", a='" + a + '\'' +
", b='" + b + '\'' +
", c='" + c + '\'' +
", d='" + d + '\'' +
'}';
}
public void eat(){
System.out.println("eat...");
}
public void eat(String food){
System.out.println("eat..."+ food);
}
}
package com.itheima.day01.reflect;
import java.lang.reflect.Method;
public class ReflectDemo4 {
public static void main(String[] args) throws Exception {
Class personClass = Person.class;
//获取指定名称的成员方法
Method eatMethod =personClass.getMethod("eat");
Person p = new Person();
//执行方法
eatMethod.invoke(p);//输出:eat...
Method eatMethod1 =personClass.getMethod("eat",String.class);
eatMethod1.invoke(p,"chifan"); //输出:eat...chifan
System.out.println("------------");
//获取所有public修饰的方法
Method[] methods = personClass.getMethods();
for(Method method:methods){
// public java.lang.String com.itheima.day01.reflect.Person.toString()
// public java.lang.String com.itheima.day01.reflect.Person.getName()
// public void com.itheima.day01.reflect.Person.setName(java.lang.String)
// public void com.itheima.day01.reflect.Person.eat()
// public void com.itheima.day01.reflect.Person.eat(java.lang.String)
// public int com.itheima.day01.reflect.Person.getAge()
// public void com.itheima.day01.reflect.Person.setAge(int)
// public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
// public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
// public final void java.lang.Object.wait() throws java.lang.InterruptedException
// public boolean java.lang.Object.equals(java.lang.Object)
// public native int java.lang.Object.hashCode()
// public final native java.lang.Class java.lang.Object.getClass()
// public final native void java.lang.Object.notify()
// public final native void java.lang.Object.notifyAll()
System.out.println(method);
String name = method.getName();
// toString
// getName
// setName
// getAge
// setAge
// eat
// eat
// wait
// wait
// wait
// equals
// hashCode
// getClass
// notify
// notifyAll
System.out.println(name);
method.setAccessible(true);
}
//获取类名
String className = personClass.getName();
System.out.println(className); //输出:com.itheima.day01.reflect.Person
System.out.println(personClass.getPackage()); //输出:package com.itheima.day01.reflect
}
}
7、案例
写一个“框架”,不能改变该类的任何代码的前提下,可以帮我们创建任意类的对象,并且执行其中任意方法
实现:
a. 配置文件
b. 反射
步骤:
a. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
b.在程序中加载读取配置文件
c. 使用反射技术来加载文件进内存
d. 创建对象
e. 执行方法
src下创建一个pro.properties配置文件
package com.itheima.day01.reflect;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
/**
* 框架类
*/
public class ReflectTest {
public static void main(String[] args) throws Exception {
//1.加载配置文件
//1.1 创建Properties对象
Properties pro = new Properties();
//1.2 加载配置文件,转换为一个集合(Properties是一个Map集合类)
//1.3 获取class目录下的配置文件
ClassLoader classLoader= ReflectTest.class.getClassLoader();//获取ReflectTest.class文件的类加载器
System.out.println(classLoader); //jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc
InputStream is = classLoader.getResourceAsStream("pro.properties");//从classpath的根路径下查找pro.properties文件
pro.load(is);
//2.获取配置文件中定义的数据
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");
//3. 加载该类进内存
Class cls = Class.forName(className);
//4. 创建对象
Object obj = cls.newInstance();
//5. 获取方法对象
Method method = cls.getMethod(methodName);
//6. 执行方法
method.invoke(obj);//Person类的eat方法被执行,输出:eat...
//不改变此类的任何方法,只需要改pro.properties配置文件即可
//系统庞大,改Java代码需要重新测试编译上线,改配置文件改完就可以了,扩展性更强
}
}
System.out.println(classLoader);//jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc