Java中的反射用法及說明
更新時間：2025年07月21日 09:25:19 作者：「已注銷」
Java反射機制允許運行時動態(tài)獲取和操作類的成員（屬性、方法、構造器）,通過Class對象實現(xiàn),廣泛應用于框架開發(fā)及動態(tài)調(diào)用需求,支持繞過泛型限制、讀取配置文件等場景
一、反射的概述
反射的引入：
問題：IDEA中的對象是怎么知道類有哪些屬性，哪些方法的呢？
- 通過反射技術對象類進行了解剖得到了類的所有成員。
反射的概念
- 反射是一種機制，利用該機制可以在程序運行過程中對類進行解剖并操作類中的所有成員(成員變量，成員方法，構造方法)
使用反射操作類成員的前提
- 要獲得該類字節(jié)碼文件對象，就是Class對象
反射機制的功能:
- 在運行時獲取【任意】一個對象所屬的類型
- 在運行時獲取【任意】一個類的構造
- 在運行時構造【任意】一個類的對象
- 在運行時獲取【任意】一個類所具有的成員變量
- 在運行時設置或者獲取【任意】一個屬性的值
- 在運行時獲取【任意】一個類所具有的成員方法
- 在運行時調(diào)用【任意】一個對象的方法
反射在實際開發(fā)中的應用
- 開發(fā)IDE(集成開發(fā)環(huán)境)，比如IDEA,Eclipse
- 各種框架的設計和學習 比如Spring，Hibernate，Struct，Mybaits…
提示！
在所有的具備的功能中，都是針對任意的對象進行操作，說明反射機制具備很強的靈活性和通用性。
總體而言：
Java的反射機制可以動態(tài)性的操作類、屬性、方法，為此都推出了相應的類來進行描述：
- Class類：描述所有的類的類型；
- Constructor類：描述所有的構造的類型；
- Field類：描述所有的屬性的類型；
- Method類：描述所有的方法的類型；
以上所有的這些類，其實就是將一個class類進行了分解。
二、Class類對象獲取的三種方式
2.1、三種獲取方式
方式1: 通過類名.class獲得
方式2：通過對象名.getClass()方法獲得
方式3：通過Class類的靜態(tài)方法獲得： static Class forName(“類全名”)
- 每一個類的Class對象都只有一個。
package com.reflection;
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 com.reflection;
/**
* @Author: 史小創(chuàng)
* @Time: 2024/8/10 上午9:32
* @Description: 反射的簡單使用
*/
public class ReflectDemo01 {
public static void main(String[] args) throws ClassNotFoundException {
// 1. 獲取Class對象
Class<Student> c1 = Student.class;
// 2. 創(chuàng)建對象
Student student = new Student();
// 3. 通過對象名.getclass方法獲
Class c2 = student.getClass();
// 判斷兩者是不是同一個對象
System.out.println(c1 == c2);
// 通過class類靜態(tài)方法獲得：
Class<?> c3 = Class.forName("com.reflection.Student");
System.out.println(c1 == c3);
System.out.println(c2 == c3);
}
}
2.2、Class類的常用方法
- String getSimpleName(); 獲得類名字符串：類名
- String getName(); 獲得類全名：包名+類名
- T newInstance() ; 創(chuàng)建Class對象關聯(lián)類的對象
package com.reflection;
/**
* @Author: 史小創(chuàng)
* @Time: 2024/8/10 上午9:51
* @Description: Class類常用方法
*/
public class ReflectDemo02 {
public static void main(String[] args) throws Exception {
// 獲得Class對象
Class c = Student.class;
// 獲得類名字符串：類名
System.out.println(c.getSimpleName());
// 獲得類全名：包名+類名
System.out.println(c.getName());
// 創(chuàng)建對象
Student stu = (Student) c.newInstance();
System.out.println(stu);
}
}
三、反射之操作構造方法
反射之操作構造方法的目的：獲得Constructor對象來創(chuàng)建類的對象。
Constructor類概述：類中的每一個構造方法都是一個Constructor類的對象
| 方法名 | 說明 |
|---|---|
| Constructor<?>[] getConstructors() | 返回所有公共構造方法對象的數(shù)組 |
| Constructor<?>[] getDeclaredConstructors() | 返回所有構造方法對象的數(shù)組 |
| Constructor getConstructor(Class<?>… parameterTypes) | 返回單個公共構造方法對象 |
| Constructor getDeclaredConstructor(Class<?>… parameterTypes) | 返回單個構造方法對象 |
package com.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
* @Author: 史小創(chuàng)
* @Time: 2024/8/10 上午10:13
* @Description: Constructor類的概述
*/
public class ReflectDemo03 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
// 獲取class對象
Class<?> aClass = Class.forName("com.reflection.Student");
// Constructor<?>[] getConstructors() 返回一個包含 Constructor對象的數(shù)組， Constructor對象反映了由該 Class對象表示的類的所有公共構造函數(shù)
// Constructor<?>[] cons = c.getConstructors();
// Constructor<?>[] getDeclaredConstructors() 返回反映由該 Class對象表示的類聲明的所有構造函數(shù)的 Constructor對象的數(shù)組
Constructor<?>[] cons = aClass.getDeclaredConstructors();
for (Constructor<?> con : cons) {
System.out.println(con);
}
System.out.println("--------");
// Constructor<T> getConstructor(Class<?>... parameterTypes) 返回一個 Constructor對象，該對象反映由該 Class對象表示的類的指定公共構造函數(shù)
// Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回一個 Constructor對象，該對象反映由此 Class對象表示的類或接口的指定構造函數(shù)
// 參數(shù)：你要獲取的構造方法的參數(shù)的個數(shù)和數(shù)據(jù)類型對應的字節(jié)碼文件對象
Constructor<?> con = aClass.getConstructor();
// Constructor提供了一個類的單個構造函數(shù)的信息和訪問權限
// T newInstance(Object... initargs) 使用由此 Constructor對象表示的構造函數(shù)，使用指定的初始化參數(shù)來創(chuàng)建和初始化構造函數(shù)的聲明類的新實例
Object obj = con.newInstance();
System.out.println(obj);
System.out.println("--------");
Student s = new Student();
System.out.println(s);
}
}
3.1、反射獲取構造方法并使用練習1
案例需求
- 通過反射獲取公共的構造方法并創(chuàng)建對象
package com.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
* @Author: 史小創(chuàng)
* @Time: 2024/8/10 下午12:13
* @Description:
*/
public class ReflectDemo04 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
// 獲取class類對象
Class<?> aClass = Class.forName("com.reflection.Student");
// public Student(String name, int age, String address)
// Constructor<T> getConstructor(Class<?>... parameterTypes)
Constructor<?> con = aClass.getConstructor(String.class, int.class, String.class);
// 基本數(shù)據(jù)類型也可以通過.class得到對應的Class類型
// T newInstance(Object... initargs)
Object obj = con.newInstance("林青霞", 30, "西安");
System.out.println(obj);
}
}
3.2、反射獲取構造方法并使用練習2
案例需求
- 通過反射獲取私有構造方法并創(chuàng)建對象
package com.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
* @Author: 史小創(chuàng)
* @Time: 2024/8/10 下午12:18
* @Description:
*/
public class ReflectDemo05 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
// 獲取class類對象
Class<?> aClass = Class.forName("com.reflection.Student");
//private Student(String name)
//Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
Constructor<?> con = aClass.getDeclaredConstructor(String.class);
//暴力反射
//public void setAccessible(boolean flag):值為true，取消訪問檢查
con.setAccessible(true);
Object obj = con.newInstance("林青霞");
System.out.println(obj);
}
}
四、反射之操作成員方法
- 反射之操作成員方法的目的：操作Method對象來調(diào)用成員方法
- Method類概述：每一個成員方法都是一個Method類的對象。
| 方法名 | 說明 |
|---|---|
| Method[] getMethods() | 返回所有公共成員方法對象的數(shù)組，包括繼承的 |
| Method[] getDeclaredMethods() | 返回所有成員方法對象的數(shù)組，不包括繼承的 |
| Method getMethod(String name, Class<?>… parameterTypes) | 返回單個公共成員方法對象 |
| Method getDeclaredMethod(String name, Class<?>… parameterTypes) | 返回單個成員方法對象 |
Method類用于執(zhí)行方法的方法
| 方法名 | 說明 |
|---|---|
| Objectinvoke(Object obj,Object… args) | 調(diào)用obj對象的成員方法，參數(shù)是args,返回值是Object類型 |
package com.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* @Author: 史小創(chuàng)
* @Time: 2024/8/10 下午12:24
* @Description:
*/
public class ReflectDemo06 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
// 獲取class類對象
Class<?> aClass = Class.forName("com.reflection.Student");
// Method[] getMethods() 返回一個包含 方法對象的數(shù)組， 方法對象反映由該 Class對象表示的類或接口的所有公共方法，包括由類或接口聲明的對象以及從超類和超級接口繼承的類
// Method[] getDeclaredMethods() 返回一個包含 方法對象的數(shù)組， 方法對象反映由 Class對象表示的類或接口的所有聲明方法，包括public，protected，default（package）訪問和私有方法，但不包括繼承方法
// Method[] methods = c.getMethods();
Method[] methods = aClass.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("--------");
// Method getMethod(String name, Class<?>... parameterTypes) 返回一個 方法對象，該對象反映由該 Class對象表示的類或接口的指定公共成員方法
// Method getDeclaredMethod(String name, Class<?>... parameterTypes) 返回一個 方法對象，它反映此表示的類或接口的指定聲明的方法 Class對象
// public void method1()
Method m = aClass.getMethod("method1");
Constructor<?> con = aClass.getConstructor();
Object o = con.newInstance();
// 注意這種方法是錯誤的
// o.m();
// 在類或接口上提供有關單一方法的信息和訪問權限
// Object invoke(Object obj, Object... args) 在具有指定參數(shù)的指定對象上調(diào)用此 方法對象表示的基礎方法
// Object：返回值類型
// obj：調(diào)用方法的對象
// args：方法需要的參數(shù)
m.invoke(o);
}
}
反射獲取成員方法并使用練習：通過反射獲取成員方法并調(diào)用
package com.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* @Author: 史小創(chuàng)
* @Time: 2024/8/10 下午12:39
* @Description:
*/
public class ReflectDemo07 {
public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
// 獲取class類對象
Class<?> c = Class.forName("com.reflection.Student");
// Student s = new Student();
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
// s.method1();
Method m1 = c.getMethod("method1");
m1.invoke(obj);
System.out.println("--------");
// s.method2("林青霞");
Method m2 = c.getMethod("method2", String.class);
m2.invoke(obj, "林青霞");
System.out.println("--------");
// 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);
System.out.println("--------");
// s.function();
Method m4 = c.getDeclaredMethod("function");
m4.setAccessible(true);
m4.invoke(obj);
}
}
五、反射之操作成員變量
反射之操作成員變量的目的：通過Field對象給對應的成員變量賦值和取值
Field類概述：每一個成員變量都是一個Field類的對象。
| 方法名 | 說明 |
|---|---|
| Field[] getFields() | 返回所有公共成員變量對象的數(shù)組 |
| Field[] getDeclaredFields() | 返回所有成員變量對象的數(shù)組 |
| Field getField(String name) | 返回單個公共成員變量對象 |
| Field getDeclaredField(String name) | 返回單個成員變量對象 |
Field類用于給成員變量賦值的方法
| 方法名 | 說明 |
|---|---|
| voidset(Object obj,Object value) | 給obj對象的成員變量賦值為value |
package com.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
/**
* @Author: 史小創(chuàng)
* @Time: 2024/8/10 下午12:46
* @Description:
*/
public class ReflectDemo08 {
public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException, NoSuchFieldException {
// 獲取class類對象
Class<?> c = Class.forName("com.reflection.Student");
// Field[] getFields() 返回一個包含 Field對象的數(shù)組， Field對象反映由該 Class對象表示的類或接口的所有可訪問的公共字段
// Field[] getDeclaredFields() 返回一個 Field對象的數(shù)組，反映了由該 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 address = c.getField("address");
// 獲取無參構造方法創(chuàng)建對象
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
// obj.addressField = "西安";
// Field提供有關類或接口的單個字段的信息和動態(tài)訪問
// void set(Object obj, Object value) 將指定的對象參數(shù)中由此 Field對象表示的字段設置為指定的新值
address.set(obj, "西安");
System.out.println(obj);
System.out.println("--------");
Student s = new Student();
s.address = "西安";
System.out.println(s);
}
}
反射獲取成員變量并使用練習:
案例需求
- 通過反射獲取成員變量并賦值
package com.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
/**
* @Author: 史小創(chuàng)
* @Time: 2024/8/10 下午12:53
* @Description:
*/
public class ReflectDemo09 {
public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException, NoSuchFieldException {
// 獲取class類對象
Class<?> c = Class.forName("com.reflection.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);
}
}
六、綜合案例
6.1、越過泛型檢查
通過反射技術，向一個泛型為Integer的集合中添加一些字符串數(shù)據(jù)
package com.reflection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
/**
* @Author: 史小創(chuàng)
* @Time: 2024/8/10 下午12:57
* @Description: 通過反射技術，向一個泛型為Integer的集合中添加一些字符串數(shù)據(jù)
*/
public class ReflectDemo10 {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
ArrayList<Integer> array = new ArrayList<>();
// 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);
}
}
6.2、運行配置文件中指定類的指定方法
通過反射運行配置文件中指定類的指定方法
package com.reflection;
public class Teacher {
public void teach() {
System.out.println("用愛成就學員");
}
}
class.txt文件：
className=com.reflection.Teacher methodName=teach
package com.reflection;
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;
/**
* @Author: 史小創(chuàng)
* @Time: 2024/8/10 下午1:05
* @Description:
*/
public class ReflectDemo11 {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, IOException, ClassNotFoundException, InstantiationException {
// 加載數(shù)據(jù)
Properties prop = new Properties();
FileReader fr = new FileReader("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);// study
m.invoke(obj);
}
}
環(huán)境說明：
總結
以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。
相關文章
這篇文章主要介紹了Java異常處理的相關資料,幫助大家更好的理解和學習java，感興趣的朋友可以了解下2020-08-08
Java并發(fā)編程之volatile與JMM多線程內(nèi)存模型
這篇文章主要介紹了Java并發(fā)volatile與JMM多線程內(nèi)存模型,本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2022-05-05
springboot實現(xiàn)rabbitmq消息確認的示例代碼
RabbitMQ的消息確認有兩種, 一種是消息發(fā)送確認,第二種是消費接收確認,本文主要介紹了springboot實現(xiàn)rabbitmq消息確認的示例代碼,具有一定的參考價值,感興趣的可以了解一下2023-09-09
這篇文章主要介紹了Java Stream流之求和的實現(xiàn)，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2021-02-02
這篇文章主要介紹了詳解SpringMVC注解功能及屬性，文中通過詳細的示例代碼作了簡要的分析，有需要的朋友可以借鑒參考下，希望可以有所幫助2021-09-09
這篇文章主要介紹了idea中JRebel不生效問題及解決方案，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-03-03
Java多線程--讓主線程等待所有子線程執(zhí)行完畢在執(zhí)行
Java主線程等待所有子線程執(zhí)行完畢在執(zhí)行，其實在我們的工作中經(jīng)常的用到，本篇文章就介紹了Java多線程--讓主線程等待所有子線程執(zhí)行完畢在執(zhí)行，有需要的可以了解一下。2016-11-11
java 直接調(diào)用python腳本，并傳遞參數(shù)代碼實例
這篇文章主要介紹了java調(diào)用python腳本傳遞參數(shù)的方法，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2019-04-04
這篇文章主要介紹了啟用設置org.slf4j.Logger打印并輸出日志方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2023-11-11
springboot如何接收text/plain參數(shù)
這篇文章主要介紹了springboot如何接收text/plain參數(shù)的實現(xiàn)方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2025-06-06