反射
反射是 Java 核心的基础技术之一，它赋予程序在运行时动态获取类信息的能力。通过反射，我们可以在程序运行时探知类的构造器、方法、字段等详细信息，从而实现更灵活的代码。本文将深入探讨 Java 中的反射机制，了解其定义、工作原理、应用场景，并通过具体的代码示例来演示如何使用反射。
什么是反射
反射 是一种能够在运行时获取类信息的能力。它可以让程序在不知道类的情况下，通过类的全限定名来获取类的字节码文件，并在运行时对类的各种属性进行操作。这些信息包括类的构造器、方法、变量、接口、父类、注解等。
为什么会有反射
在某些情况下，程序无法在编译时就确定所需要操作的对象类型。例如，框架或库在运行时可能需要加载用户自定义的类，或根据用户配置动态创建对象和调用方法。在这种情况下，反射提供了极大的灵活性，让我们可以在运行时动态地获取类信息、创建对象、调用方法、修改属性等。
反射是如何工作的
要使用反射获取类的信息，我们首先需要获取类的 Class 对象。在 Java 中，有三种方式可以获得 Class 对象：
Class.forName("全类名")：通过类的全限定名（包括包名）获取 Class 对象。
对象.getClass()：通过对象的 getClass() 方法获取 Class 对象。
一旦获取了类的 Class 对象，就可以使用反射 API 来获取类的详细信息，例如构造器、方法、字段等。
反射的应用
以下是一个具体的例子，展示了如何使用反射来获取类的构造器、方法和字段信息。我们将创建一个 Student 类，并在一个 Test 类中使用反射来操作 Student 类。
//Student类
public class Student {
private String name="张三";
public Integer age=18;
Character sex='男';
protected Double height =185.5;
public String color ="蓝色";
public void run(){
System.out.println("这是run()");
}
private int getAge(int age){
System.out.println("age()");
return age;
}
void aaa(String name,Integer height){
System.out.println("aaa()");
}
protected void haha(String name,int age){
System.out.println("haha()");
}
public Student(){}
private Student(String name){}
public Student(String name,Integer age){}
public Student(String name, Integer age, Character sex, Double height, String color) {
this.name = name;
this.age = age;
this.sex = sex;
this.height = height;
this.color = color;
}
}想要获取类信息就必须进入类对象阶段，以下是进入类对象阶段的三种方式
public class Test {
public static void main(String[] args) throws Exception {
//1、想要获取类信息就必须进入类对象阶段，以下是进入类对象阶段的三种方式
Class class1=Class.forName("反射.Student");
Class class2=Student.class;
Student student =new Student();
Class class3=student.getClass();
System.out.println(class1==class2);
System.out.println(class2==class3);
System.out.println("------------");
//2、以class1为例进行变量信息的获取
//①获取全部的变量信息，并且打印
Field[] files=class1.getDeclaredFields();
System.out.println(Arrays.toString(files));
System.out.println("------------");
//②获取public修饰的全局变量信息，并打印
Field[] fiels1=class1.getFields();
System.out.println(Arrays.toString(fiels1));
System.out.println("------------");
//③获取任意一个变量信息
Field nameField =class1.getDeclaredField("name");
System.out.println(nameField);
Field hightField =class1.getDeclaredField("height");
System.out.println(hightField);
Field ageField =class1.getDeclaredField("age");
System.out.println(ageField);
System.out.println("------------");
//④获取任意一个public修饰的变量信息
Field ageField1 =class1.getField("age");
System.out.println(ageField1);
System.out.println("------------");
//3以class1为例进行方法信息的获取
//①获取全部方法信息
Method[] declaredMethods=class1.getDeclaredMethods();
System.out.println(Arrays.toString(declaredMethods));
System.out.println("------------");
//②获取public修饰的方法信息
Method[] methods =class1.getMethods();
System.out.println(Arrays.toString(methods));
System.out.println("------------");
//③获取任意一个方法信息
Method getAge =class1.getDeclaredMethod("getAge", int.class);
Method aaa =class1.getDeclaredMethod("aaa", String.class, Integer.class);
Method run=class1.getDeclaredMethod("run");
Method hhh=class1.getDeclaredMethod("haha", String.class, int.class);
System.out.println(hhh);
System.out.println(aaa);
System.out.println(run);
System.out.println(getAge);
System.out.println("------------");
//④获取任意一个public修饰的方法信息
Method run1 =class1.getMethod("run");
System.out.println(run1);
System.out.println("------------");
以class1为例进行构造器的获取，构造器一般都是public类型的若有其他类型用getDeclaredConstructors获取
//4、以class1为例进行构造器的获取，构造器一般都是public类型的若有其他类型用getDeclaredConstructors获取
//①获取所有的构造器
Constructor[] declaredconstructors =class1.getDeclaredConstructors();
System.out.println(Arrays.toString(declaredconstructors));
System.out.println("------------");
//②获取public修饰的构造器
Constructor[] constructors =class1.getConstructors();
System.out.println(Arrays.toString(constructors));
System.out.println("------------");
//③获取任意某个public修饰的构造器
Constructor declaredconstructor =class1.getDeclaredConstructor();
Constructor declaredconstructor1 =class1.getDeclaredConstructor(String.class ,Integer.class);
Constructor declaredconstructor2 =class1.getDeclaredConstructor(String.class,Integer.class ,Character.class ,Double.class ,String.class);
System.out.println(declaredconstructor);
System.out.println(declaredconstructor1);
System.out.println(declaredconstructor2);
System.out.println("------------");//5对构造器的调用
// ①public修饰的构造器的使用(以该代码所获取的构造器信息为例 Constructor declaredconstructor1 =class1.getDeclaredConstructor(String.class ,Integer.class))
//创建对象 需要强转
Student student1 = (Student) declaredconstructor1.newInstance("aaa",18);
System.out.println("------------");
// ②private修饰的构造器的调用,但想要使用必须暴力反射，而protected、和不写的不需要暴力反射
Constructor declaredconstructor4=class1.getDeclaredConstructor(String.class);
declaredconstructor4.setAccessible(true);
Student student2= (Student) declaredconstructor4.newInstance("AAA");
System.out.println("------------");对方法的调用(以该代码所获取的构造器信息为例 Constructor declaredconstructor1 =class1.getDeclaredConstructor(String.class ,Integer.class))
// 6对方法的调用(以该代码所获取的构造器信息为例 Constructor declaredconstructor1 =class1.getDeclaredConstructor(String.class ,Integer.class))
//创建该对象 Student student1 = (Student) declaredconstructor1.newInstance("aaa",18);
//①对public修饰方法的调用
Method run2= class1.getDeclaredMethod("run");
run2.invoke(student1);
System.out.println("------------");
//②对private修饰方法的调用 需要暴力反射
Method getAge1= class1.getDeclaredMethod("getAge", int.class);
getAge1.setAccessible(true);
getAge1.invoke(student1,18);
System.out.println("------------");
//③不写修饰的方法的调用
Method aaa1 =class1.getDeclaredMethod("aaa", String.class, Integer.class);
aaa1.invoke(student1,"admin",199);
System.out.println("------------");
//对protected修饰方法的调用
Method haha1=class1.getDeclaredMethod("haha", String.class, int.class);
haha1.invoke(student1,"admin",99);
System.out.println("------------");
对变量的调用赋值取值操作(以该代码所获取的构造器信息为例 Constructor declaredconstructor1 =class1.getDeclaredConstructor(String.class ,Integer.class))
// 7对变量的调用赋值取值操作(以该代码所获取的构造器信息为例 Constructor declaredconstructor1 =class1.getDeclaredConstructor(String.class ,Integer.class))
//创建该对象 Student student1 = (Student) declaredconstructor1.newInstance("aaa",18);
//①给privat修饰的变量赋值，取值操作，需要暴力反射
Field name=class1.getDeclaredField("name");
name.setAccessible(true);
name.set(student1,"admin");
System.out.println(name.get(student1));
System.out.println("------------");
//②其他类型不需要
Field age=class1.getDeclaredField("age");
age.set(student1,88);
System.out.println(age.get(student1));
System.out.println("------------");
Field sex=class1.getDeclaredField("sex");
sex.set(student1,'女');
System.out.println(sex.get(student1));
System.out.println("------------");
Field height=class1.getDeclaredField("height");
height.set(student1,188.88);
System.out.println(height.get(student1));
}
}
反射的练习
获取该类的构造方法来构造对象，获取该类的名称和该类中每一个变量的名称和方法名称，并执行相关方法，给没一个变量赋值，并获取值，执行每一个构造方法、执行相应的方法
在实际应用中，我们可以使用反射来动态操作对象和调用方法，下面是一个练习示例：
//获取该类的构造方法来构造对象，获取该类的名称和该类中每一个变量的名称和方法名称，并执行相关方法，给没一个变量赋值，并获取值，执行每一个构造方法、执行相应的方法
public class Student {
private String name;
private int age;
private String address;
public Student(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
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;
}
public String getAddress(){
return address;
}
public void setAddress(String address){
this.address=address;
}
}
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Test {
public static void main(String[] args) throws Exception {
Class class1=Class.forName("反射练习.Student");
// 获取并打印类名
System.out.println("类的名称: " + class1.getName());
// 获取并打印所有字段（变量）名称
System.out.println("变量名称为");
Field[] fields = class1.getDeclaredFields();
for (Field field : fields) {
System.out.println( field.getName());
}
System.out.println("-----------");
// 获取并打印所有方法名称（包括继承的方法）
Method[] methods = class1.getMethods();
System.out.println("方法名称为");
for (Method method : methods) {
System.out.println( method.getName());
}
System.out.println("-----------");
Constructor declaredconstructor1 =class1.getDeclaredConstructor(String.class ,int.class,String.class);
Student student1= (Student) declaredconstructor1.newInstance("李四",18,"北京 ");
Field name=class1.getDeclaredField("name");
name.setAccessible(true);
System.out.println(name.get(student1));
Field age=class1.getDeclaredField("age");
age.setAccessible(true);
System.out.println(age.get(student1));
Field address=class1.getDeclaredField("address");
address.setAccessible(true);
System.out.println(address.get(student1));
System.out.println("-----------");
Method setname= class1.getDeclaredMethod("setName", String.class);
setname.invoke(student1,"张三");
Method getname= class1.getDeclaredMethod("getName");
getname.invoke(student1);
Method setAge= class1.getDeclaredMethod("setAge", int.class);
setAge.invoke(student1,20);
Method getAge= class1.getDeclaredMethod("getAge");
getAge.invoke(student1);
Method setaddress= class1.getDeclaredMethod("setAddress", String.class);
setaddress.invoke(student1,"上海");
Method getaddress= class1.getDeclaredMethod("getAddress");
getaddress.invoke(student1);
Field name1=class1.getDeclaredField("name");
name1.setAccessible(true);
System.out.println(name1.get(student1));
Field age1=class1.getDeclaredField("age");
age1.setAccessible(true);
System.out.println(age1.get(student1));
Field address1=class1.getDeclaredField("address");
address1.setAccessible(true);
System.out.println(address1.get(student1));
}
}
Java 的反射机制为我们提供了在运行时动态操作类和对象的能力，使得代码更具灵活性和适应性。通过反射，我们可以在未知类的情况下创建对象、调用方法、修改属性，这在很多高级应用场景中都是不可或缺的工具。希望本文能够帮助您更好地理解和使用反射。
23万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
