反射的基本用法
1. 获取Class类的对象：
- 使用类的class属性来获取该类对应的Class对象。举例：Student.class将会返回Student类对应的Class对象。
- 调用对象的getClass()方法，返回该对象所属类对应的Class对象，该方法式Object类中的方法，所有的Java对象都可以调用该方法。
- 使用Class类中的静态方法forName(String className)，该方法需要传入字符串参数，该字符串参数的值是某个类的全路径，也就是完整包名的路径。
Student类：
package chen.fanShe.fanShe_01;
public class Student {
//成员变量：一个私有，一个默认，一个公共
private String name;
Integer age;
public String address;
//构造方法：一个私有，一个默认，两个公共
public Student(){
}
private Student(String name){
this.name=name;
}
Student(String name,int age){
this.name=name;
this.age=age;
}
public Student(String name,int age,String address){
this.name=name;
this.age=age;
this.address=address;
}
//成员方法：一个私有，四个公共
private void function(){
System.out.println("function");
}
private void method1(){
System.out.println("method");
}
public void method2(String s){
System.out.println("method:"+s);
}
public String method3(String s,int i){
return s+","+i;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
'}';
}
}
获取Class类对象的三种方法：
package chen.fanShe.fanShe_01;
public class ReflectDemo1 {
//获取Class类的对象的三种方式
public static void main(String[] args) throws ClassNotFoundException {
//使用类的class属性来获取该类对应的Class对象
Class<Student> c1 = Student.class;
System.out.println(c1);
Class<Student> c2 = Student.class;
System.out.println(c1==c2);
System.out.println("-------");
//调用对象的getClass()方法，返回该对象所属类对应的Class对象
Student s=new Student();
Class<? extends Student> c3 = s.getClass();
System.out.println(c1==c3);
System.out.println("-------");
//使用Class类中的静态方法forName(String className)，参数为：类的全路径
Class<?> c4 = Class.forName("chen.fanShe.fanShe_01.Student");
System.out.println(c1==c4);
}
}
运行结果：
2. 反射获取构造方法并使用
2.1 Class类中用于获取构造方法的方法
- Constructor<?>[] getConstructors()：返回所有公共构造方法对象的数组
- Constructor<?>[] getDeclaredConstructors()：返回所有构造方法对象的数组
- Constructor[] getConstructor(Class<?>… parameterTypes)：返回单个公共构造方法对象
- Constructor[] getDeclaredConstructor(Class<?>… parameterTypes)：返回单个构造方法对象
2.2 Constructor类中用于创建对象的方法
- T newInstance(Object… initargs)：根据指定的构造方法创建对象
- 暴力反射：值为true，取消访问检查，用在非公共方法前。public void setAccessible(boolean flag)
例子：declaredConstructor3.setAccessible(true);
package chen.fanShe.fanShe_02;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/*
* 反射获取构造方法并使用
* */
public class ReflectDemo2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//获取Class对象
Class<?> c = Class.forName("chen.fanShe.fanShe_01.Student");
//返回所有公共构造方法对象的数组
Constructor<?>[] publicCons = c.getConstructors();
for (Constructor publicCon:publicCons){
System.out.println(publicCon);
}
System.out.println("----------------------------------------------------------");
//返回所有构造方法对象的数组
Constructor<?>[] cons = c.getDeclaredConstructors();
for (Constructor con:cons){
System.out.println(con);
}
System.out.println("----------------------------------------------------------");
//返回单个公共构造方法对象
//参数：你要获取的构造方法的参数的个数和数据类型对应的字节码文件对象
Constructor<?> constructor1 = c.getConstructor(String.class,int.class,String.class);
System.out.println(constructor1);
System.out.println("*******************");
Constructor<?> constructor2 = c.getConstructor();
System.out.println(constructor2);
System.out.println("----------------------------------------------------------");
//返回单个构造方法对象
Constructor<?> declaredConstructor1 = c.getDeclaredConstructor();
System.out.println(declaredConstructor1);
System.out.println("*******************");
Constructor<?> declaredConstructor2 = c.getDeclaredConstructor(String.class);
System.out.println(declaredConstructor2);
System.out.println("*******************");
Constructor<?> declaredConstructor3 = c.getDeclaredConstructor(String.class,int.class);
System.out.println(declaredConstructor3);
System.out.println("*******************");
Constructor<?> declaredConstructor4 = c.getDeclaredConstructor(String.class,int.class,String.class);
System.out.println(declaredConstructor4);
System.out.println("----------------------------------------------------------");
Object obj1 = declaredConstructor1.newInstance();
System.out.println(obj1);
//暴力反射：值为true，取消访问检查。用在非公共方法前。
declaredConstructor2.setAccessible(true);
Object obj2 = declaredConstructor2.newInstance("张三");
System.out.println(obj2);
//暴力反射：值为true，取消访问检查。用在非公共方法前。
declaredConstructor3.setAccessible(true);
Object obj3 = declaredConstructor3.newInstance("李四",20);
System.out.println(obj3);
Object obj4 = declaredConstructor4.newInstance("林青霞",30,"西安");
System.out.println(obj4);
}
}
运行结果：
3. 反射获取成员变量并使用
3.1 Class类中用于获取成员变量的方法
- Field[] getFields()：返回所有公共成员变量对象的数组
- Field[] getDeclaredFields()：返回所有成员变量对象的数组
- Field[] getField(String name)：返回单个公共成员变量对象
- Field[] getDeclaredField(String name)：返回单个成员变量对象
3.2 Field类中用于给成员变量赋值的方法
- void set(Object obj, Object value)：给obj对象的成员变量赋值为value
package chen.fanShe.fanShe_03;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
/*
* 反射获取成员变量并使用
* */
public class ReflectDemo3 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//获取Class对象
Class<?> c = Class.forName("chen.fanShe.fanShe_01.Student");
//返回所有公共成员变量对象的数组
Field[] fields = c.getFields();
for (Field field:fields){
System.out.println(field);
}
System.out.println("----------------------------------------------------------");
//返回所有成员变量对象的数组
Field[] declaredFields = c.getDeclaredFields();
for (Field declaredField:declaredFields){
System.out.println(declaredField);
}
System.out.println("----------------------------------------------------------");
//返回单个公共成员变量对象
Field field_address = c.getField("address");
System.out.println(field_address);
System.out.println("----------------------------------------------------------");
//返回单个成员变量对象
Field declaredField_name = c.getDeclaredField("name");
System.out.println(declaredField_name);
System.out.println("*******************");
Field declaredField_age = c.getDeclaredField("age");
System.out.println(declaredField_age);
System.out.println("*******************");
Field declaredField_address = c.getDeclaredField("address");
System.out.println(declaredField_address);
System.out.println("----------------------------------------------------------");
//获取无参构造方法创建对象
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
//取消访问检查，为非公共类型的成员变量赋值前使用
declaredField_name.setAccessible(true);
declaredField_name.set(obj,"李四");
//取消访问检查，为非公共类型的成员变量赋值前使用
declaredField_age.setAccessible(true);
declaredField_age.set(obj,18);
declaredField_address.set(obj,"北京"); //给obj的成员变量赋值
System.out.println(obj);
}
}
运行结果：
4. 反射获取成员方法并使用
4.1 Class类中用于获取成员方法的方法
- Method[] getMethods()：返回所有公共成员方法对象的数组，包括继承的
- Method[] getDeclaredMethods()：返回所有成员方法对象的数组，不包括继承的
- Method[] getMethod(String name, Class<?>… parameterTypes)：返回单个公共成员方法对象
- Method[] getDeclaredMethod(String name, Class<?>… parameterTypes)：返回单个成员方法对象
4.2 Method类中用于调用成员方法的方法
- Object invoke(Object obj, Object… args)：调用obj对象的成员方法，参数是args，返回值是Object类型
package chen.fanShe.fanShe_04;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/*
* 反射获取成员方法并使用
* */
public class ReflectDemo4 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//获取Class对象
Class<?> c = Class.forName("chen.fanShe.fanShe_01.Student");
//返回所有公共成员方法对象的数组，包括继承的
Method[] methods = c.getMethods();
for (Method method:methods){
System.out.println(method);
}
System.out.println("----------------------------------------------------------");
//返回所有成员方法对象的数组，不包括继承的
Method[] declaredMethods = c.getDeclaredMethods();
for (Method declaredMethod:declaredMethods){
System.out.println(declaredMethod);
}
System.out.println("----------------------------------------------------------");
//返回单个公共成员方法对象
Method method2 = c.getMethod("method2", String.class);
System.out.println(method2);
System.out.println("*******************");
Method method3 = c.getMethod("method3", String.class,int.class);
System.out.println(method3);
System.out.println("----------------------------------------------------------");
//返回单个成员方法对象
Method declaredMethod_function = c.getDeclaredMethod("function");
System.out.println(declaredMethod_function);
System.out.println("*******************");
Method declaredMethod1 = c.getDeclaredMethod("method1");
System.out.println(declaredMethod1);
System.out.println("*******************");
Method declaredMethod2 = c.getDeclaredMethod("method2", String.class);
System.out.println(declaredMethod2);
System.out.println("*******************");
Method declaredMethod3 = c.getDeclaredMethod("method3", String.class,int.class);
System.out.println(declaredMethod3);
System.out.println("----------------------------------------------------------");
//获取无参构造方法创建对象
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
//在类或接口上提供有关单一方法的信息和访问权限
declaredMethod_function.setAccessible(true);
declaredMethod_function.invoke(obj); //这句就是方法的调用
//调用有参数和有返回值的函数
Object method3_return = method3.invoke(obj, "张三", 18);
System.out.println(method3_return);
}
}
运行结果：
5. 反射练习
5.1 练习1：使用反射，在一个ArrayList< Integer>集合中添加一个字符串数据。
package chen.fanShe;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
/*
* 在一个ArrayList<Integer>集合中添加字符串数据
* */
public class ReflectTest01 {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
//创建集合
ArrayList<Integer> arrayList=new ArrayList<Integer>();
Class<? extends ArrayList> aClass = arrayList.getClass();
Method m = aClass.getMethod("add", Object.class);
m.invoke(arrayList,"hello");
m.invoke(arrayList,"world");
m.invoke(arrayList,"java");
m.invoke(arrayList,10);
System.out.println(arrayList);
}
}
运行结果：
5.2 练习2：通过配置文件运行类中的方法
创建Student和Teacher两个类：
package chen.fanShe.fanShe_06;
public class Student {
public void study() {
System.out.println("好好学习，天天向上！");
}
}
package chen.fanShe.fanShe_06;
public class Teacher {
public void teach() {
System.out.println("用爱成就学生！");
}
}
创建配置文件class.txt
className=chen.fanShe.fanShe_06.Student
methodName=study
实现代码示例：
package chen.fanShe.fanShe_06;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;
public class ReflectTest06 {
public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
// 加载class.txt中的数据
Properties prop = new Properties();
FileReader fr = new FileReader("E:\\IDEA_workspace\\JavaSE\\class.txt");
prop.load(fr);
fr.close();
String className = prop.getProperty("className");
String methodName = prop.getProperty("methodName");
// 通过反射来使用
Class<?> c = Class.forName(className);
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
Method m = c.getMethod(methodName);
m.invoke(obj);
}
}
运行结果
修改class.txt中的内容，原示例代码不变：
className=chen.fanShe.fanShe_06.Teacher
methodName=teach
再次运行结果
111
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
