溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要講解了“Java反射有什么優點”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Java反射有什么優點”吧！
Java中創建對象大概有這幾種方式：
1、使用new關鍵字：這是我們最常見的也是最簡單的創建對象的方式
2、使用Clone的方法：無論何時我們調用一個對象的clone方法，JVM就會創建一個新的對象，將前面的對象的內容全部拷貝進去
3、使用反序列化：當我們序列化和反序列化一個對象，JVM會給我們創建一個單獨的對象
上邊是Java中常見的創建對象的三種方式，其實除了上邊的三種還有另外一種方式，就是接下來我們要討論的 “反射”
在程序運行狀態中，對于任意一個類或對象，都能夠獲取到這個類的所有屬性和方法（包括私有屬性和方法），這種動態獲取信息以及動態調用對象方法的功能就稱為反射機制。簡單來講，通過反射，類對我們是完全透明的，想要獲取任何東西都可以。
反射它把Java類中的各個部分，映射成一個個的Java對象，拿到這些對象后可以做一些事情。既然說反射是反射Java類中的各個組成部分，所以說我們得知道一個類中有哪兒些部分？
例如，一個類有：成員變量，方法，構造方法，等信息，利用反射技術咱們可以把這些組成部分映射成一個個對象。
一般來說反射是用來做框架的，或者說可以做一些抽象度比較高的底層代碼，反射在日常的開發中用到的不多，但是我們還必須搞懂它，因為搞懂了反射以后，可以幫助咱們理解框架的一些原理。所以說有一句很經典的話：反射是框架設計的靈魂。
可以在程序運行過程中，操作這些對象；
可以解耦，提高程序的可擴展性。
在學習反射以前，我們先來了解一下Java代碼在計算機中所經歷的三個階段：
Source源代碼階段：.java被編譯成*.class字節碼文件。
Class類對象階段：.class字節碼文件被類加載器加載進內存，并將其封裝成Class對象（用于在內存中描述字節碼文件），Class對象將原字節碼文件中的成員變量抽取出來封裝成數組Field[],將原字節碼文件中的構造函數抽取出來封裝成數組Construction[]，將成員方法封裝成數組Method[]。當然Class類內不止這三個，還封裝了很多，我們常用的就這三個。
RunTime運行時階段：使用new創建對象的過程。
【Source源代碼階段】 Class.forName(“全類名”)：將字節碼文件加載進內存，返回Class對象；
多用于配置文件，將類名定義在配置文件中，通過讀取配置文件加載類。
【Class類對象階段】 類名.class：通過類名的屬性class獲取；
多用于參數的傳遞
【Runtime運行時階段】對象.getClass()：此方法是定義在Objec類中的方法，因此所有的類都會繼承此方法。
多用于對象獲取字節碼的方式
//方法演示
public class getClass {
public static void main(String[] args) throws Exception {
//方式一：Class.forName("全類名");
Class class1 = Class.forName("com.czxy.mybatis_plus.test.Person"); //Person自定義實體類
System.out.println("class1 = " + class1);
//方式二：類名.class
Class class2 = Person.class;
System.out.println("class2 = " + class2);
//方式三：對象.getClass();
Person person = new Person();
Class class3 = person.getClass();
System.out.println("class3 = " + class3);
//比較三個對象
System.out.println(class1 == class2); //true
System.out.println(class1 == class3); //true
}
}運行結果：
通過上述比較三個對象的結果可以得出一個結論：同一個字節碼文件(*.class)在一次程序運行過程中，只會被加載一次，無論通過哪一種方式獲取的Class對象都是同一個。
這里只寫出一些常用的，具體可以參看jdk的幫助文檔。
獲取成員變量
Field[] getFields() //獲取所有public修飾的成員變量Field getField(String name) //獲取指定名稱的public修飾的成員變量Field[] getDeclaredFields() //獲取所有的成員變量，不考慮修飾符Field getDeclaredField(String name) //獲取指定的成員變量，不考慮修飾符
2. 獲取構造方法
Constructor<?>[] getConstructors() //獲取所有public修飾的構造函數Constructor<T> getConstructor(類<?>... parameterTypes) //獲取指定的public修飾的構造函數Constructor<?>[] getDeclaredConstructors() //獲取所有的構造函數，不考慮修飾符Constructor<T> getDeclaredConstructor(類<?>... parameterTypes) //獲取指定的構造函數，不考慮修飾符
3. 獲取成員方法
Method[] getMethods() //獲取所有public修飾的成員方法Method getMethod(String name, 類<?>... parameterTypes) //獲取指定名稱的public修飾的成員方法Method[] getDeclaredMethods() //獲取所有的成員方法，不考慮修飾符Method getDeclaredMethod(String name, 類<?>... parameterTypes) //獲取指定名稱的成員方法，不考慮修飾符
4. 獲取全類名
String getName()
（1）設置值 set(Object obj, Object value)
（2）獲取值 get(Object obj)
（3）忽略訪問權限修飾符的安全檢查 setAccessible(true):暴力反射
import lombok.Data;
import lombok.ToString;
@Data
@ToString
public class Person {
public String a; //最大范圍public
protected String b; //受保護類型
String c; //默認的訪問權限
private String d; //私有類型
}/**
* 獲取成員變量
* * Field[] getFields()
* * Field getField(String name)
* @throws Exception
*/
public class reflectDemo{
public static void main(String[] args) throws Exception {
//獲取Person的Class對象
Class personClass = Person.class;
//1、Field[] getFields()獲取所有public修飾的成員變量
Field[] fields = personClass.getFields();
for(Field field : fields){
System.out.println(field);
}
System.out.println("=============================");
//2.Field getField(String name) 獲取指定名稱的public修飾的成員變量
Field a = personClass.getField("a");
//獲取成員變量a的值 [也只能獲取公有的，獲取私有的或者不存在的字符會拋出異常]
Person p = new Person();
Object value = a.get(p);
System.out.println("value = " + value);//因為在Person類中a沒有賦值，所以為null
//設置成員變量a的屬性值
a.set(p,"李四");
System.out.println(p);
}
}運行結果：
/**
* Field[] getDeclaredFields()
* Field getDeclaredField(String name)
* @throws Exception
*/
public class reflectDemo1 {
public static void main(String[] args) throws Exception {
//獲取Person的Class對象
Class personClass = Person.class;
//Field[] getDeclaredFields()：獲取所有的成員變量，不考慮修飾符
Field[] declaredFields = personClass.getDeclaredFields();
for(Field filed : declaredFields){
System.out.println(filed);
}
System.out.println("===================================");
//Field getDeclaredField(String name) //獲取指定的成員變量，不考慮修飾符
Field d = personClass.getDeclaredField("d"); //private String d;
Person p = new Person();
//Object value1 = d.get(p); //如果直接獲取會拋出異常，因為對于私有變量雖然能會獲取到，但不能直接set和get，必須忽略訪問權限修飾符的安全檢查后才可以
//System.out.println("value1 = " + value1);
//忽略訪問權限修飾符的安全檢查，又稱為暴力反射
d.setAccessible(true);
Object value2 = d.get(p);
System.out.println("value2 = " + value2);
}
}運行結果：
注意：如果沒有忽略訪問修飾符直接訪問會拋出如下所示的異常
import lombok.Data;
import lombok.ToString;
@Data
@ToString
public class Person {
private String name;
private Integer age;
//無參構造函數
public Person() {
}
//單個參數的構造函數，且為私有構造方法
private Person(String name){
}
//有參構造函數
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
}/**
* 獲取構造方法
* Constructor<?>[] getConstructors()
* Constructor<T> getConstructor(類<?>... parameterTypes)
*/
public class reflectDemo2{
public static void main(String[] args) throws Exception {
//獲取Person的Class對象
Class personClass = Person.class;
//Constructor<?>[] getConstructors() //獲取所有public修飾的構造函數
Constructor[] constructors = personClass.getConstructors();
for(Constructor constructor : constructors){
System.out.println(constructor);
}
System.out.println("==========================================");
//獲取無參構造函數 注意：Person類中必須要有無參的構造函數，不然拋出異常
Constructor constructor1 = personClass.getConstructor();
System.out.println("constructor1 = " + constructor1);
//使用獲取到的無參構造函數創建對象
Object person1 = constructor1.newInstance();
System.out.println("person1 = " + person1);
System.out.println("==========================================");
//獲取有參的構造函數 //public Person(String name, Integer age) 參數類型順序要與構造函數內一致，且參數類型為字節碼文件類型
Constructor constructor2 = personClass.getConstructor(String.class,Integer.class);
System.out.println("constructor2 = " + constructor2);
//使用獲取到的有參構造函數創建對象
Object person2 = constructor2.newInstance("zhangsan", 22); //獲取的是有參的構造方法，就必須要指定參數
System.out.println(person2);
System.out.println("=========================================");
//對于一般的無參構造函數，我們都不會先獲取無參構造器之后在進行初始化,而是直接調用Class類內的newInstance()方法
Object person3 = personClass.newInstance();
System.out.println("person3 = " + person3);
}
}運行結果：
import lombok.Data;
import lombok.ToString;
@Data
@ToString
public class Person {
private String name;
private Integer age;
//無參構造函數
public Person() {
}
//有參構造函數
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
//無參方法
public void test(){
System.out.println("test...");
}
//重載有參方法
public void test(String food){
System.out.println("test..."+food);
}
}/**
* 獲取成員方法
* * Method[] getMethods()
* * Method getMethod(String name, 類<?>... parameterTypes)
*/
public class reflectDemo3 {
public static void main(String[] args) throws Exception {
//獲取Person的Class對象
Class personClass = Person.class;
//獲取指定名稱的方法
Method method1 = personClass.getMethod("test");
//執行方法
Person person = new Person();
Object rtValue = method1.invoke(person);//如果方法有返回值類型可以獲取到，沒有就為null
//因為eat方法沒有返回值，故輸出null
System.out.println("rtValue = " + rtValue);
System.out.println("--------------------------------------------");
//獲取有參的函數，有兩個參數：第一個參數為方法名，第二個參數是獲取方法的參數類型的字節碼文件
Method method2 = personClass.getMethod("test", String.class);
//執行方法
method2.invoke(person,"嗨");
System.out.println("============================================");
//獲取方法列表
Method[] methods = personClass.getMethods();
for(Method method : methods){ //注意：獲取到的方法不僅僅是Person類內自己的方法
System.out.println(method); //繼承Object中的方法也會被獲取到（當然前提是public修飾的）
}
}
}運行結果 ：
我們可以看出Person內的public方法都被打印出來了，此外Object中的public方法也都被打印出來了。
同之前的敘述一樣，帶有Declared關鍵字的方法這兩個方法，可以獲取到任意修飾符的方法。同樣也提供了setAccessible(true)方法進行暴力反射。
綜上所述：在反射面前沒有公有私有，都可以通過暴力反射解決。
public class getNameDemo {public static void main(String[] args) throws Exception {//獲取Person的Class對象Class personClass = Person.class;//獲取全類名String className = personClass.getName();System.out.println(className);}}運行結果：
寫一個"框架"，在不改變該類的任何代碼的前提下，可以幫我們創建任意類的對象，并且執行其中的任意方法。
（1）配置文件
（2）反射機制
（1）將需要創建的對象的全類名和需要執行的方法定義在配置文件中
（2）在程序中加載讀取配置文件
（3）使用反射技術把類文件加載進內存
（4）創建對象
（5）執行方法
(1)Person類
public class Person {
//無參方法
public void test(){
System.out.println("test...");
}
}(2)Student類
public class Student {//無參方法public void study(){System.out.println("I'm Student");}}className = com.czxy.mybatis_plus.test.Person methodName = test
/**
* 前提：不能改變該類的任何代碼。可以創建任意類的對象，可以執行任意方法
* 即：拒絕硬編碼
*/
public class ReflectTest {
public static void main(String[] args) throws Exception {
//1.加載配置文件
//1.1創建Properties對象
Properties pro = new Properties();
//1.2加載配置文件
//1.2.1獲取class目錄下的配置文件(使用類加載器)
ClassLoader classLoader = ReflectTest.class.getClassLoader();
InputStream inputStream = classLoader.getResourceAsStream("pro.properties");
pro.load(inputStream);
//2.獲取配置文件中定義的數據
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");
//3.加載該類進內存
Class cls = Class.forName(className);
//4.創建對象
Object obj = cls.newInstance();
//5.獲取方法對象
Method method = cls.getMethod(methodName);
//6.執行方法
method.invoke(obj);
}
}運行結果:
className = com.czxy.mybatis_plus.test.Student methodName = study
運行結果:
感謝各位的閱讀，以上就是“Java反射有什么優點”的內容了，經過本文的學習后，相信大家對Java反射有什么優點這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
