目录
概述
反射：框架设计的灵魂
框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
概念：将类的各个组成部分封装为其他对象，这就是反射机制
java代码的三个阶段
反射的好处：
1、可以在程序的运行过程中，操作这些对象
例如：idea有自动编译功能（将变量、构造方法、成员方法，都加载到内存中去）
创建一个字符串后
String str="abc";
要提示的时候只需要将method中的所有方法展示就好了
所以idea的代码提示也是一种反射机制
2、可以解耦，提供程序的可扩展性。
获取Class对象的方式
三种方式对应三个阶段
Source源码阶段（未加载进内存）：
Class.forName("全类名"):这是一个静态方法，将字节码文件加载进内存，返回Class对象
多用于配置文件，将类名称定义在配置文件中。读取文件，加载类
Class类对象阶段（已加载进内存）：
类名.Class：通过类名的属性Class获取
多用于参数的传递
Runtime运行时阶段：
对象.getClass()
getClass方法在Object类中定义
多用于对象的获取字节码的方式
演示：
public static void main(String[] args) throws ClassNotFoundException {
//1、Class.forName("全类名")
Class<?> cls1 = Class.forName("反射.Person");
System.out.println(cls1);
//2、类名.Class
Class<Person> cls2 = Person.class;
System.out.println(cls2);
//3、对象.getClass()
Person p=new Person();
Class cls3 = p.getClass();
System.out.println(cls3);
//用==比较三个对象
System.out.println(cls1==cls2);
System.out.println(cls1==cls3);
/*
结论：
同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个
*/
}
例子中的Person类
源码
/*用于测试反射的Person类*/
public class Person {
4中权限修饰符
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 + '\'' +
'}';
}
public void eat(){
System.out.println("eat...");
}
//写一个重载
public void eat(String food){
System.out.println("eat..."+food);
}
}
Class功能方法
/*
Class功能：
获取功能：
1、获取成员变量们
Field[] getFields()
Field getField(String name)
Field[] getDeclaredFields()
Field getDeclaredField(String name)
2、获取构造方法们
getConstructor(类<?>... parameterTypes)
Constructor<?>[] getConstructors()
Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
Constructor<?>[] getDeclaredConstructors()
3、获取成员方法们
method getMethod(String name, 类<?>... parameterTypes)
method[] getMethods()
method getDeclaredMethod(String name, 类<?>... parameterTypes)
method[] getDeclaredMethods()
4、获取类名
String getName()
*/
注意：这些方法中不带Declared的只能获取公共的，带Declared什么你都能获取到
具体用法分开讲解
获取成员变量
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
//1、获取Person的字节码对象
Class<Person> personClass = Person.class;
//获取成员变量们
/*
获取功能：
1、获取成员变量们
Field[] getFields()获取所有public修饰的成员方法
Field getField(String name)获取指定名称public修饰的成员变量
Field[] getDeclaredFields():获取所有的成员变量，不考虑修饰符
Field getDeclaredField(String name):根据名称获取
*/
//Field[] getFields()获取所有public修饰的成员方法
Field[] fields = personClass.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("---------");
// Field getField(String name)获取指定名称public修饰的成员变量
Field a = personClass.getField("a");
/*
Field：成员变量
操作：
1、设置值
void set(Object obj,Object value)
2、获取值
get(Object obj)
暴力反射，设置为true后private就可以访问了
setAccessible(true);
*/
Person p=new Person();
//传入对象，获取值
Object value = a.get(p);
//打印值
System.out.println(value);
//设置值
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);//暴力反射，设置为true后就可以访问了
Object value2 = d.get(p);//直接访问会报错，需要暴力反射
System.out.println(value2);
}
获取构造方法
public class Demo3 {
/*
2、获取构造方法们
效果同理成员变量的获取
Constructor<T>getConstructor(类<?>... parameterTypes)
Constructor<?>[] getConstructors()
Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
Constructor<?>[] getDeclaredConstructors()
*/
public static void main(String[] args) throws Exception {
Class personClass = Person.class;
//getConstructor(类<?>... parameterTypes)
//传递的参数不同得到的构造方法也不同（无参or有参）
//这里暂时不指定泛型，指定Person类可以返回Person对象的构造器
Constructor constructor = personClass.getConstructor(String.class, int.class);
System.out.println(constructor);
//Constructor的操作
/*
创建对象：
T newInstance(Object... initargs)
若果使用空参数构造方法创建对象，操作可以简化：
Class对象里的newInstance方法,jdk9以后过时了，因为该方法绕过了异常处理
关于访问私有构造方法：
构造器对象同样可以使用私有的构造器创建对象，也需要使用
constructor.setAccessible(true);
*/
//创建对象，上边得到的构造方法没指定泛型所以要用Object接收
Object person = constructor.newInstance("张三", 23);
System.out.println(person);
System.out.println("-----------");
//空参的构造方法
Constructor constructor1 = personClass.getConstructor();
System.out.println(constructor1);
//不传参数
Object person1 = constructor1.newInstance();
System.out.println(person1);
Object o = personClass.newInstance();//已过时
System.out.println(o);
}
}
获取成员方法
public class Demo3 {
/*
3、获取成员方法们
method getMethod(String name, 类<?>... parameterTypes)
method[] getMethods()
method getDeclaredMethod(String name, 类<?>... parameterTypes)
method[] getDeclaredMethods()
*/
public static void main(String[] args) throws Exception{
Class<Person> personClass = Person.class;
//获取指定名称的方法
//方法有三要素，方法名、返回值列表、参数列表。所以填入的参数要确定一个方法需要方法名和参数列表
Method eat_method = personClass.getMethod("eat");
/*
Method:方法对象
执行方法：
Object invoke(Object obj,Object...args)
需要传递真实的对象(该对象只能是所属类的对象)和实际参数列表
*/
//创建一个真实的对象
Person p=new Person();
//执行方法
eat_method.invoke(p);
//获取eat的带参重载
Method eat_method2 = personClass.getMethod("eat", String.class);
eat_method2.invoke(p,"饭");
//获取方法名称
String name = eat_method.getName();
System.out.println(name);
System.out.println("--------------");
//获取所有的public方法,会获取出隐藏的方法Object类的方法
Method[] methods = personClass.getMethods();
for (Method method : methods) {
System.out.println(method);
}
//同样访问私有方法也是同样的
// declaredMethod.setAccessible(true);
//注意：只能操作单个对象时才能调用setAccessible方法
//获取类名直接在这里写出
String className = personClass.getName();
System.out.println(className);
}
}
使用反射的案例
/*需求写一个“框架”,可以帮我们创建任意类的对象，并且执行其中任意的方法*/
public class Practice {
public static void main(String[] args) throws Exception {
/*
前提：不能改变该类的任何代码
实现：
1、配置文件
2、反射
步骤：
1、将需要创建的对象的全类名和需要执行的方法定义在配置文件中
2、在程序中加载读取配置文件
3、使用反射技术来加载类文件进内存
4、创建对象
5、执行方法
*/
//1、加载配置文件
Properties pro=new Properties();
//1.2加载配置文件转换为一个集合
//1.2.1获取class目录下的配置文件
//这步获取了这个字节码文件对应的类加载器
ClassLoader classLoader = Practice.class.getClassLoader();
//ClassLoader既然可以找到类路径下的class文件，那么也可以找到配置文件
/*
classloader中的两个方法
getResource方法，获取资源的路径
getResourceAsStream()方法，获取资源对应的字节流
*/
InputStream is = classLoader.getResourceAsStream("\\reflect_test\\pro.properties");
这里经过测试得出以根目录src开始查找，需要写出包含配置文件的包名
pro.load(is);
//2、获取配置文件中定义的数据
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");
//3、加载该类进内存
Class<?> cls = Class.forName(className);
//4、创建对象
Constructor<?> constructor = cls.getConstructor();
Object obj = constructor.newInstance();
//5、获取方法对象
Method method = cls.getMethod(methodName);
//6、执行方法
method.invoke(obj);
}
}
960
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
