一、反射概述
基本概念：
反射是一种机制，利用该机制可以在程序运行过程中对类进行解剖，并操作类中的方法、属性构造方法等成员；
可以理解为，反射就是创建对象，调用方法，给成员变量赋值和取值的一种方式；
反射就是通过获取到一个类的Class对象来操作里面成员数据并执行相关操作的过程；
应用场景：
开发IDE编译器（集成开发环境，比如IDEA，Eclipse）
开发框架（Spring、SpringMVC、Mybatis。。。）
学习框架
反射的前提条件：
必须先获得字节码文件对象：Class对象
获得Class对象的三种方式：
通过类名.class获取
通过对象名.getClass（）获取
通过Class.forName（“类全名字符串”）获取
public class test {
public static void main(String[] args) throws ClassNotFoundException {
//1.通过类名.class获取
Class sortClass = HeapSort.class;
//2.通过getClass()方法
Class heap = new HeapSort().getClass();
//通过Class.forName
Class name = Class.forName("HeapSort");
//由于只有一个class对象，所以上面这三种方式都会获取到同一个对象
System.out.println(sortClass);
System.out.println(heap);
System.out.println(name);
}
}
获取Class对象属性的方法：
public class test {
public static void main(String[] args) throws ClassNotFoundException {
//1.通过类名.class获取
Class sortClass = HeapSort.class;
//获取类全名，因为我的项目是类是直接放在src包下的，所以类全名就是类名
System.out.println(sortClass.getName());
//获取类名
System.out.println(sortClass.getSimpleName());
}
}
二、反射操作构造方法
Constructor类概述：
类中的每一个构造方法都是一个Constructor类的对象，反射操作构造方法就是要获得构造方法对应的Constructor对象，然后通过该对象来创建类对象；
获得Constructor对象：
要注意，这里只能是Class对象来获得Constructor对象
//根据参数类型，获得对应的构造方法对象，只能获取到以public修饰的
Constructor getConstructor(Class... paramterTypes)
//根据参数类型，获得对应的构造方法对象，包括private
Constructor getDeclaredConstructor(Class... paramterTypes)
Constructor对象常用方法：
//根据参数创建实例对象
T newInstance(Object 。。。 args)
//设置是否可访问，是否取消权限检查，暴力反射
//true：取消权限检查，可以访问private修饰的
//false：要检查权限，默认值
//要在上面这个方法调用前使用
void setAcessible(true)
Student类：
package com.ps.pojo;
public class Student {
private String username;
private String password;
public Student(String username, String password) {
System.out.println("双参构造");
}
private Student(String username) {
System.out.println("一个参构造");
}
public Student() {
System.out.println("无参构造");
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "Student{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}
test类：
package com.ps.test;
import com.ps.pojo.Student;
import org.junit.Test;
import java.lang.reflect.Constructor;
public class StuTest {
@Test
public void test1() throws Exception {
Class c = Student.class;
Constructor<Student> con = c.getConstructor();
Student student = con.newInstance();
}
@Test
public void test2() throws Exception {
Class c = Student.class;
Constructor<Student> con = c.getConstructor(String.class, String.class);
Student student = con.newInstance("123", "123");
}
@Test
public void test3() throws Exception {
Class c = Student.class;
//如果不改变方法，是获取不到private修饰的构造方法
Constructor<Student> con = c.getDeclaredConstructor(String.class);
//如果不加这个，就无法创造对象，对于权限不通过的构造方法，需要这样来访问
con.setAccessible(true);
Student student = con.newInstance("123");
}
}
运行结果：
三、反射操作成员方法
Method类概述：
类中的每一个成员方法都是一个method对象，反射操作成员方法就是要获得该方法的method对象，通过调用method对象调用方法；
获得Method：
//根据方法名和参数类型获得对应的method对象，但是只能是public修饰的
Method getMethod(String methodName,Class ... args);
//和上面的方法功能一样，但是它可以private修饰的
Method getDeclaredMethod(String methodName,Class ... args);
//获得当前类的所有成员方法对象，包括父类的，但是只能是public修饰的
Method[] getMethods();
//获得当前类的所有成员方法对象，包括private修饰的，但是只能是本类的
Method[] getDeclaredMethods();
常用方法：
//执行调用的方法
//obj是这个类的对象，后面是方法需要传入的值
//前面的object是返回值
Object invoke(Object obj,Object ... args);
//取消权限检查，暴力反射
//true取消权限检查
//false检查权限
void setAcessible(true);
代码样例：
test代码：
package com.ps.test;
import com.ps.pojo.Student;
import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class StuTest {
@Test
public void test4() throws Exception {
Class c = Student.class;
Constructor constructor = c.getConstructor();
//获得类对象
Object stu = constructor.newInstance();
Method method = c.getMethod("eat");
//调用类方法
method.invoke(stu);
}
@Test
public void test5() throws Exception {
Class c = Student.class;
Constructor constructor = c.getConstructor();
Object stu = constructor.newInstance();
//设置参数类型
Method method = c.getMethod("sleep", String.class, int.class);
//传入参数，调用方法
method.invoke(stu, "床上", 10);
}
@Test
public void test6() throws Exception {
Class c = Student.class;
Constructor constructor = c.getConstructor();
Object stu = constructor.newInstance();
Method method = c.getDeclaredMethod("study", int.class);
//取消权限检查
method.setAccessible(true);
method.invoke(stu, 10);
}
@Test
public void test7() throws Exception {
Class c = Student.class;
Constructor constructor = c.getConstructor();
Object stu = constructor.newInstance();
Method[] method = c.getMethods();
for (Method method1 : method) {
System.out.println(method1);
}
}
@Test
public void test8() throws Exception {
Class c = Student.class;
Constructor constructor = c.getConstructor();
Object stu = constructor.newInstance();
Method[] method = c.getDeclaredMethods();
for (Method method1 : method) {
System.out.println(method1);
}
}
}
pojo代码：
package com.ps.pojo;
public class Student {
private String username;
private String password;
public void eat(){
System.out.println("我正在吃海鲜大餐");
}
public void sleep(String site,int hour){
System.out.println("我在"+site+"睡了"+hour+"小时");
}
private void study(int hour){
System.out.println("学习学了"+hour+"小时");
}
public Student(String username, String password) {
System.out.println("双参构造");
}
private Student(String username) {
System.out.println("一个参构造");
}
public Student() {
System.out.println("无参构造");
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "Student{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}
运行结果：
四、反射操作成员变量
Field类概述：
类中的每一个成员变量都是Field类的对象，反射操作成员变量，就是获得成员变量对应的Field对象，通过Field对象给成员变量赋值。
获得Field对象：
//其实也是有不带Declared的方法的，但是由于成员变量基本都是private修饰的
//所以几乎不会用到哪两种方式
//根据成员变量名获得Field对象，包括private修饰的
Field getDeclaredField(String name);
//获得当前类所有的成员变量对象
Field[] getDeclaredFields();
//获取属性的类型，返回class对象。
Class getType();
Field常用方法：
//获得指定对象obj对应成员变量的值
int getint(object obj)
object get (object obj)
long getLong(object obj)
boolean getBoolean(object ob)
double getDouble (object obj)
//设置指定对象obj对应成员变量的值
void set(object obj,Object value)
void setInt (object obj, int i)
void setLong(object obj, long l)
void setBoolean (object obj, boolean z)
void setDouble (object obj, double d)
//和之前一摸一样的暴力反射
void setAcessible(true);
代码样例：
@Test
public void test9() throws Exception {
Class c = Student.class;
Constructor constructor = c.getConstructor();
Object stu = constructor.newInstance();
Field field = c.getDeclaredField("username");
field.setAccessible(true);
System.out.println(stu);
field.set(stu, "207401255");
System.out.println(stu);
Object o = field.get(stu);
System.out.println(o);
}
运行结果：
由于和前面两个太相似了，所以就不过多赘述和演示了；
五、实现读取properties配置文件创建对象
pojo类：
和之前的没有太大区别
package com.ps.pojo;
public class Student {
private String username;
private String password;
public void eat(){
System.out.println("我正在吃海鲜大餐");
}
public void sleep(String site,int hour){
System.out.println("我在"+site+"睡了"+hour+"小时");
}
private void study(int hour){
System.out.println("学习学了"+hour+"小时");
}
public Student(String username, String password) {
System.out.println("双参构造");
}
private Student(String username) {
System.out.println("一个参构造");
}
public Student() {
System.out.println("无参构造");
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "Student{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}
stu.properties:（直接放在src目录下面）
class=com.ps.pojo.Student
username=ps
password=123456
主要实现：
package com.ps.pojo;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.Properties;
import java.util.Set;
public class demo {
public static void main(String[] args) throws Exception {
//由于我函数中编写的是通过Class.class中的方法获取的流
//所以只需要把文件放到src目录下
//编写的之后/+文件名即可读取到数
Student obj = (Student) getObj("/stu.properties");
//student类编写了toString方法，所以可以直接输出
System.out.println(obj);
}
public static Object getObj(String filename) throws Exception {
//1.创建配置信息读取类
Properties properties = new Properties();
//2.把配置文件读取到配置信息类的对象中
properties.load(Class.class.getResourceAsStream(filename));
//3.获得类全名
Object ClassStr = properties.get("class");
//4.获得Class对象
Class targetClass = Class.forName((String) ClassStr);
//5.获得构造方法对象
Constructor constructor = targetClass.getConstructor();
//6.反射机制调用空参构造方法
Object obj = constructor.newInstance();
//7.遍历集合把数据填入到对象中
Set<String> set = properties.stringPropertyNames();
for (String s : set) {
//8.如果遇到class字符串则不处理
if (s.equals("class"))
continue;
//9.获得成员变量对象和value值,要记得使用带有declared，不然访问不到
Field field = targetClass.getDeclaredField(s);
String values = properties.getProperty(s);
//10.暴力反射
field.setAccessible(true);
//11.判断成员变量的类型，通过合适的类型来设置参数
if (field.getType() == int.class) {
field.setInt(obj, Integer.parseInt(values));
} else if (field.getType() == double.class) {
field.setDouble(obj, Double.parseDouble(values));
} else if (field.getType() == boolean.class) {
field.setBoolean(obj, Boolean.parseBoolean(values));
} else if (field.getType() == byte.class) {
field.setByte(obj, Byte.parseByte(values));
} else if (field.getType() == float.class) {
field.setFloat(obj, Float.parseFloat(values));
} else if (field.getType() == short.class) {
field.setShort(obj, Short.parseShort(values));
} else if (field.getType() == long.class) {
field.setLong(obj, Long.parseLong(values));
} else if (field.getType() == char.class) {
//如果是char类型的话，就只有一个，所以直接获取即可
field.setChar(obj, s.charAt(0));
} else {
field.set(obj, values);
}
}
//12.返回创建好，并把成员变量也设置好的对象
return obj;
}
}
658
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
