本文详细介绍了Java反射机制，包括反射概述、获取Class对象的三种方式，以及如何通过反射获取和使用构造方法、成员变量和方法。通过实例展示了如何创建对象、设置成员变量值、调用方法，并提供了多个反射练习，帮助读者深入理解Java反射的应用。
1、反射概述
Java反射机制：是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，然后调用方法的一种机制，由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展
2、获取Class类的对象
我们要想通过反射去使用一个类，首先我们就要获取到该类的字节码文件对象，也就是类型为Class类型的对象
获取Class类型的对象的三种方式：
- 使用类的class属性来获取该类对应的Class对象
- 举例：Student.class将会返回Student类对应的Class对象
- 调用对象的getClass()方法，返回该对象所属类对应的Class对象
- 该方法是Object类中的方法，所有的Java对象都可以调用该方法
- 使用Class类中的静态方法forName(String className)，该方法需要传入字符串参数，该字符串参数的值是某个类的全路径，也就是完整路径
package Reflect01;
public class Student {
//成员变量：一个私有，一个默认，一个公共
private String name;
int 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");
}
public 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 + '\'' +
'}';
}
}
-------------------------------------------------------------
package Reflect01;
/*
获取Class类型的对象的三种方式：
使用类的class属性来获取该类对应的Class对象
举例：Student.class将会返回Student类对应的Class对象
调用对象的getClass()方法，返回该对象所属类对应的Class对象
该方法是Object类中的方法，所有的Java对象都可以调用该方法
使用Class类中的静态方法forName(String className)，该方法需要传入字符串参数，该字符串参数的值是某个类的全路径，也就是完整路径
*/
public class ReflectDemo {
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("Reflect01.Student");
System.out.println(c1 == c4);
}
}
3、反射获取构造方法并使用
Class类中用于获取构造方法的方法
- Constructor<?>[] getConstructors()：返回所有公共构造方法对象的数组
- Constructor<?>[] getDeclareConstructors():返回所有构造方法对象的数组
- Constructor<T> getConstructor(Class<?>... parameterTypes):返回单个公共构造方法对象
- Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes):返回单个构造方法对象
Constructor类中用于创建对象的方法
- T newInstance(Object... initargs):根据指定的构造方法创建对象
package Reflect02;
import Reflect01.Student;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/*
反射获取构造方法并使用
*/
public class ReflectDemo01 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//获取Class对象
Class<?> c = Class.forName("Reflect01.Student");
//Constructor<?>[] getConstructors()：返回一个包含Constructor对象的数组，
// Constructor对象反应了由该Class对象表示的类的所有公共构造函数
// Constructor<?>[] cons = c.getConstructors();
//Constructor<?>[] getDeclareConstructors():返回反映由该Class对象表示的类声明的所有构造函数的Constructor对象的数组
Constructor<?>[] cons = c.getDeclaredConstructors();
for (Constructor con : cons) {
System.out.println(con);
}
System.out.println("--------");
//Constructor<T> getConstructor(Class<?>... parameterTypes)
//返回一个Constructor对象，该对象反映由此Class对象所表示的类的指定公共构造函数。ConstructorClass
//Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
//返回一个对象，该对象反映由此Class对象所表示的类或接口的指定构造函数。ConstructorClass
//参数：你要获取的构造方法的参数的个数和数据类型对应的字节码文件对象
Constructor<?> con = c.getConstructor();
//Constructor提供了一个类的单个构造函数的信息和对类的访问权限
//T newInstance(Object... initargs):使用此Constructor对象表示的构造函数创建并初始化构造函数的声明类的新实例，并具有指定的初始化参数
Object obj = con.newInstance();
System.out.println(obj);
// Student s = new Student();
// System.out.println(s);
}
}
4、反射获取构造方法并使用练习
练习1：通过反射实现如下操作
- Student s = new Student("林青霞",30,"西安");
- System.out.println(s);
- 基本数据类型也可以通过.class得到对应的Class类型
package Reflect02;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/*
通过反射实现如下操作
Student s = new Student("林青霞",30,"西安");
System.out.println(s);
*/
public class ReflectDemo02 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//获取Class对象
Class<?> c = Class.forName("Reflect01.Student");
//public Student(String name, int age, String address)
//Constructor<T> getConstructor(Class<?>... parameterTypes)
Constructor<?> con = c.getConstructor(String.class, int.class, String.class);
//基本数据类型也可以通过.class得到对应的Class类型
//T newInstance(Object... initargs)
Object obj = con.newInstance("林青霞", 30, "西安");
System.out.println(obj);
}
}
练习2：通过反射实现如下操作
- Student s = new Student("林青霞");
- System.out.println(s);
- public void setAccessible(boolean flag):值为true，取消访问检查
package Reflect02;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/*
通过反射实现如下操作
Student s = new Student("林青霞");
System.out.println(s);
*/
public class ReflectDemo03 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//获取Class对象
Class<?> c = Class.forName("Reflect01.Student");
//private Student(String name)
//Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
Constructor<?> con = c.getDeclaredConstructor(String.class);
//暴力反射
//public void setAccessible(boolean flag):值为true，取消访问检查
con.setAccessible(true);
Object obj = con.newInstance("林青霞");
System.out.println(obj);
}
}
5、反射获取成员变量并使用
Class类中用于获取成员变量的方法
- Field[] getFields():返回所有公共成员变量对象的数组
- Field[] getDeclaredFields():返回所有成员变量对象的数组
- Field getField(String name):返回单个公共成员变量对象
- Field getDeclaredField(String name)：返回单个成员变量对象
Field类中用于给成员变量赋值的方法
- void set(Object obj, Object value):给obj对象的成员变量赋值为value
package Reflect03;
import Reflect01.Student;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
/*
反射获取成员变量并使用
*/
public class ReflectDemo01 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
//获取Class对象
Class<?> c = Class.forName("Reflect01.Student");
//获取成员变量并使用
//Field[] getFields():返回一个包含Filed对象的数组，
//该数组包含一个对象，Filed对象反映由该Class对象表示的类或接口的所有可访问公共字段。
//Field[] getDeclaredFields()
//返回一个Field对象数组，该数组反映由该Class对象所表示的类或接口声明的所有字段
// Field[] fields = c.getFields();
Field[] fields = c.getDeclaredFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("-----------");
//Field getField(String name)
//返回一个Field对象，该对象反映由该Class对象所表示的类或接口的指定公共成员字段
//Field getDeclaredField(String name)
//返回一个Field对象，该对象反映由该Class对象所表示的类或接口的指定声明字段
Field addressField = c.getField("address");
//获取无参构造方法创建对象
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
// obj.addressField="西安";
//Field提供有关类或接口的单个字段的信息以及对它的动态访问
//void set(Object obj, Object value):将此对象在指定对象参数上表示的字段设置为指定的新值
addressField.set(obj,"西安");//给obj的成员变量addressField赋值为西安
System.out.println(obj);
// Student s = new Student();
// s.address = "西安";
// System.out.println(s);
}
}
6、反射获取成员变量并使用练习
练习：通过反射实现如下操作
- Student s = new Student();
- s.name = "林青霞";
- s.age = 30;
- s.address = "西安";
- System.out.println(s);
package Reflect03;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
/*
练习：通过反射实现如下操作
Student s = new Student();
s.name = "林青霞";
s.age = 30;
s.address = "西安";
System.out.println(s);
*/
public class ReflectDemo02 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
//获取Class对象
Class<?> c = Class.forName("Reflect01.Student");
//Student s = new Student();
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
System.out.println(obj);
//s.name = "林青霞";
// Field nameField = c.getField("name");//NoSuchFieldException: name
Field nameField = c.getDeclaredField("name");
nameField.setAccessible(true);
nameField.set(obj, "林青霞");
System.out.println(obj);
//s.age = 30;
Field ageField = c.getDeclaredField("age");
ageField.setAccessible(true);
ageField.set(obj, 30);
System.out.println(obj);
//s.address = "西安";
Field addressField = c.getDeclaredField("address");
addressField.setAccessible(true);
addressField.set(obj, "西安");
System.out.println(obj);
}
}
7、反射获取成员方法并使用
Class类中用于获取成员方法的方法：
- Method[] getMethods()：返回一个包含方法对象的数组，方法对象反应由该Class对象表示的类或接口的所有公共方法,包括有类或接口声明的对象以及从超类和超级接口继承的类
- Method[] getDeclaredMethods()：返回一个包含方法对象的数组，方法对象反应由该Class对象表示的类或接口的所有方法，包括public,protected,default(package)访问和private方法，但不包括继承方法
- Method getMethod(String name, Class<?>... parameterTypes)：返回一个Method对象，该对象反应由该Class对象表示的类或接口的指定公共方法
- Method getDeclaredMethod(String name, Class<?>... parameterTypes)：返回一个Method对象，该对象反应由该Class对象表示的类或接口的指定方法
Method类中用于调用成员方法的方法：
- Object invoke(Object obj, Object... args)：在具有指定参数的指定对象上调用此方法，方法对象表示的基础方法
- Object:返回值类型
- obj:调用方法的对象
- args:调用方法的参数
package Reflect04;
import Reflect01.Student;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/*
反射获取成员方法并使用
*/
public class ReflectDemo01 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, NoSuchFieldException, InvocationTargetException {
//获取Class对象
Class<?> c = Class.forName("Reflect01.Student");
//Method[] getMethods()：返回一个包含方法对象的数组，方法对象反应由该Class对象表示的类或接口的所有公共方法,包括有类或接口声明的对象以及从超类和超级接口继承的类
//Method[] getDeclaredMethods()：返回一个包含方法对象的数组，方法对象反应由该Class对象表示的类或接口的所有方法，包括public,protected,default(package)访问和private方法，但不包括继承方法
// Method[] methods = c.getMethods();
Method[] methods = c.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("--------");
//Method getMethod(String name, Class<?>... parameterTypes)：返回一个Method对象，该对象反应由该Class对象表示的类或接口的指定公共方法
//Method getDeclaredMethod(String name, Class<?>... parameterTypes)：返回一个Method对象，该对象反应由该Class对象表示的类或接口的指定方法
//public void method1()
Method m = c.getMethod("method1");
//获取无参构造方法。创建对象
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
// obj.m();
//在类或接口上提供有关单一方法的信息和访问权限
//Object invoke(Object obj, Object... args)：在具有指定参数的指定对象上调用此方法，方法对象表示的基础方法
//Object:返回值类型
//obj:调用方法的对象
//args:调用方法的参数
m.invoke(obj);
// Student s=new Student();
// s.method1();
}
}
8、反射获取成员方法并使用练习
练习：通过反射实现如下操作：
- Student s = new Student();
- s.method1();
- s.method2("林青霞");
- String ss = s.method3("林青霞",30);
- System.out.println(ss);
- s.function();
package Reflect04;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/*
练习：通过反射实现如下操作：
Student s = new Student();
s.method1();
s.method2("林青霞");
String ss = s.method3("林青霞",30);
System.out.println(ss);
s.function();
*/
public class ReflectDemo02 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//获取Class对象
Class<?> c = Class.forName("Reflect01.Student");
//Student s = new Student();
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
//s.method1();
Method m1 = c.getMethod("method1");
m1.invoke(obj);
//s.method2("林青霞");
Method m2 = c.getMethod("method2", String.class);
m2.invoke(obj, "林青霞");
//String ss = s.method3("林青霞",30);
//System.out.println(ss);
Method m3 = c.getMethod("method3", String.class, int.class);
Object o = m3.invoke(obj, "林青霞", 30);
System.out.println(o);
//s.function();
// Method m4 = c.getMethod("function");//NoSuchMethodException: Reflect01.Student.function()
Method m4 =c.getDeclaredMethod("function");//NoSuchMethodException: Reflect01.Student.function()
m4.setAccessible(true);
m4.invoke(obj);
}
}
9、反射练习
练习1：有一个ArrayList<Integer>集合，在这个集合中添加一个字符串数据
package Reflect05;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
/*
练习1：有一个ArrayList<Integer>集合，在这个集合中添加一个字符串数据
*/
public class ReflectTest01 {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
//创建集合
ArrayList<Integer> array = new ArrayList<Integer>();
// array.add(10);
// array.add(20);
// array.add("hello");//错误，不能添加字符串
Class<? extends ArrayList> c = array.getClass();
Method m = c.getMethod("add", Object.class);
m.invoke(array, "hello");
m.invoke(array, "world");
m.invoke(array, "java");
System.out.println(array);
}
}
练习2：通过配置文件运行类中的方法
package Reflect05;
public class Student {
public void study() {
System.out.println("好好学习天天向上");
}
}
--------------------------------------------------
package Reflect05;
public class Teacher {
public void teach() {
System.out.println("用爱成就学生");
}
}
--------------------------------------------------
className=Reflect05.Teacher
methodName=teach
--------------------------------------------------
package Reflect05;
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;
/*
练习2：通过配置文件运行类中的方法
*/
public class ReflectTest02 {
public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
// Student s = new Student();
// s.study();
// Teacher t=new Teacher();
// t.teach();
/*
class.txt
className=xxx
methodName=xxx
*/
//加载数据
Properties prop = new Properties();
FileReader fr = new FileReader("class.txt");
prop.load(fr);
fr.close();
/*
className=Reflect05.Student
methodName=study
*/
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);
}
}
扫一扫
278
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
