目錄
何為反射？
反射（Reflection），是指Java程式具有
在執行期
分析類以及修改其本身狀態或行為的能力
。
通俗點說 就是 透過反射我們可以
動態地
獲取一個類的所有屬性和方法，還可以操作這些方法和屬性。
例項的建立
一般我們建立一個物件例項
Person zhang = new Person（）；
雖然是簡簡單單一句，但JVM內部的實現過程是複雜的：
將硬碟上指定位置的Person。class檔案載入進記憶體
執行main方法時，在棧記憶體中開闢了main方法的空間（壓棧-進棧），然後在main方法的棧區分配了一個變數zhang。
執行new，在堆記憶體中開闢一個 實體類的 空間，分配了一個記憶體首地址值
呼叫該實體類對應的建構函式，進行初始化（如果沒有建構函式，Java會補上一個預設建構函式）。
將實體類的 首地址賦值給zhang，變數zhang就引用了該實體。（指向了該物件）
其中上圖步驟1 Classloader（類載入器） 將class檔案載入到記憶體中具體分為3個階段：載入、連線、初始化
而又在
載入階段，類載入器
會
將類對應的。class檔案中的二進位制位元組流讀入到記憶體中，將這個位元組流轉化為方法區的執行時資料結構，然後在堆區建立一個**java。lang。Class 物件**（類相關的資訊），作為對方法區中這些資料的訪問入口
然後再透過
類的例項
來執操作
類的方法和屬性
，比如
zhang。eat（）， zhang。getHeight（）
等等
如果我們使用反射的話，我們需要拿到該類Person的Class物件，再透過Class物件來操作
類的方法和屬性或者建立類的例項
Class personClass = Person。class；//這邊只是舉一個例子，獲取class物件的多種方式，本文後面再慢慢道來Object person = personClass。newInstance（）；
我們可以發現 透過new建立類的例項和反射建立類的例項，都繞不開。class檔案 和 Class類的。
。class檔案
首先我們得先了解一下 什麼是。class檔案
舉個簡單的例子，建立一個Person類：
public class Person { /** * 狀態 or 屬性 */ String name；//姓名 String sex；//性別 int height；//身高 int weight；//體重 /** * 行為 */ public void sleep（）{ System。out。println（this。name+“——”+ “睡覺”）； } public void eat（）{ System。out。println（“吃飯”）； } public void Dance（）{ System。out。println（“跳舞”）； }}
我們執行javac命令，編譯生成Person。class檔案
然後我們透過vim 16進位制 開啟它
#開啟file檔案vim Person。class #在命令模式下輸入。。 以16進位制顯示 ：%！xxd #在命令模式下輸入。。 切換回預設顯示：%！xxd -r
不同的作業系統，不同的 CPU 具有不同的指令集，JAVA能做到平臺無關性，依靠的就是 Java 虛擬機器。
。java原始碼是給人類讀的，而
.class位元組碼是給JVM虛擬機器讀的
，計算機智慧識別 0 和 1組成的二進位制檔案，所以虛擬機器就是我們編寫的程式碼和計算機之間的橋樑。
虛擬機器將我們編寫的 。java 源程式檔案編譯為 位元組碼 格式的 。class 檔案，位元組碼是各種虛擬機器與所有平臺統一使用的程式儲存格式，class檔案主要用於解決平臺無關性的中間檔案
Person。class檔案 包含Person類的所有資訊
Class類
我們來看下jdk的官方api文件對其的定義：
Class類的類表示正在執行的Java應用程式中的類和介面。 列舉是一種類，一個註釋是一種介面。 每個陣列也屬於一個反映為類物件的類，該物件由具有相同元素型別和維數的所有陣列共享。
原始Java型別（ boolean ， byte ， char ， short ， int ， long ， float和double ），和關鍵字void也表示為類物件。
類沒有公共建構函式。 相反， 類物件由Java虛擬機器自動構建，因為載入了類，並且透過呼叫類載入器中的defineClass方法。。
**java 萬物皆是Class類 **
【圖片】
我們來看下Class類的原始碼，原始碼太多了，挑了幾個重點：
public final class Class
我們可以發現Class也是類，是一種特殊的類，將我們定義普通類的共同的部分進行抽象，儲存類的屬性，方法，構造方法，類名、包名、父類，註解等和類相關的資訊。
Class類的構造方法是private，
只有JVM能建立Class例項
，我們開發人員 是無法建立Class例項的，JVM在構造Class物件時，需要傳入一個
類載入器
。
類也是可以用來儲存資料的，Class類就像 普通類的模板 一樣，用來儲存“類所有相關資訊”的類。
我們來繼續看這個利用反射的例子：
Class personClass = Person。class；
由於JVM為載入的 Person。class建立了對應的Class例項，並在該例項中儲存了該 Person。class的所有資訊，因此，如果獲取了Class例項（personClass ），我們就可以透過這個Class例項獲取到該例項對應的
Person類
的所有資訊。
反射的使用
獲取Class例項4種方式
透過物件呼叫
getClass（）
方法來獲取
Person p1 = new Person（）；Class c1 = p1。getClass（）；
像這種已經建立了物件的，再去進行反射的話，有點多此一舉。
一般是用於傳過來的是Object型別的物件，不知道具體是什麼類，再用這種方式比較靠譜
類名。class
Class c2 = Person。class；
這種需要提前知道匯入類的包，程式效能更高，比較常用，透過此方式獲取 Class 物件
，Person類不會進行初始化
透過 Class 物件的
forName（）
靜態方法來獲取，最常用的一種方式
Class c3 = Class。forName（“com。zj。demotest。domain。Person”）；
這種只需傳入類的全路徑
，
Class。forName會進行初始化initialization步驟
，即靜態初始化（會初始化類變數，靜態程式碼塊）。
透過類載入器物件的
loadClass（）
方法
public class TestReflection { public static void main（String［］ args） throws ClassNotFoundException { Person p1 = new Person（）； Class c1 = p1。getClass（）； Class c2 = Person。class； Class c3 = Class。forName（“com。zj。demotest。domain。Person”）； //第4中方式，類載入器 ClassLoader classLoader = TestReflection。class。getClassLoader（）； Class c4 = classLoader。loadClass（“com。zj。demotest。domain。Person”）； System。out。println（c1。equals（c2））； System。out。println（c2。equals（c3））； System。out。println（c3。equals（c4））； System。out。println（c1。equals（c4））； }}
loadClass的原始碼：
public Class<？> loadClass（String name） throws ClassNotFoundException { return loadClass（name， false）；}
loadClass 傳入的第二個引數是“false”，因此它不會對類進行連線這一步驟，根據
類的生命週期
我們知道，如果一個類沒有進行驗證和準備的話，是無法進行初始化過程的，即 不會進行類初始化，靜態程式碼塊和靜態物件也不會得到執行
我們將c1，c2，c3，c4進行 equals 比較
System。out。println（c1。equals（c2））；System。out。println（c2。equals（c3））；System。out。println（c3。equals（c4））；System。out。println（c1。equals（c4））；
結果：
true true true true
因為Class例項在JVM中是唯一的，所以，上述方法獲取的Class例項是同一個例項，
一個類在 JVM 中只會有一個 Class 例項
Class類常用的API
日常開發的時候，我們一般使用反射是為了
建立類例項（物件）、反射獲取類的屬性和呼叫類的方法
getName()
獲得類的完整名字
getFields（）
獲得類的public型別的屬性
getDeclaredFields（）
獲得類的所有屬性。包括
private 宣告的和繼承類
getMethods（）
獲得類的public型別的方法
getDeclaredMethods（）
獲得類的所有方法。包括
private 宣告的和繼承類
getMethod（String name， Class［］ parameterTypes）
獲得類的特定方法，name引數指定方法的名字，parameterTypes 引數指定方法的引數型別。
getConstructors（）
獲得類的public型別的構造方法
getConstructor（Class［］ parameterTypes）
獲得類的特定構造方法，parameterTypes 引數指定構造方法的引數型別
newInstance（）
透過類的不帶引數的構造方法建立這個類的一個物件
getSuperClass（）
用於返回表示該 Class 表示的任何類、介面、原始型別或任何 void 型別的
超類的Class(即父類)
。
。。。
。。。
我們這邊就不全部展開講了，挑幾個重點講解一下
建立物件
呼叫class物件的
newInstance（）
方法
Class c1 = Class。forName（“com。zj。demotest。domain。Person”）；Person p1 = （Person） c1。newInstance（）；p1。eat（）；
結果：
吃飯
注意：Person類必須有一個
無參的構造器
且
類的構造器的訪問許可權不能是private
使用指定構造方法
Constructor
來建立物件
如果我們非得讓Person類的無參構造器設為private呢，我們可以獲取對應的Constructor來建立物件
Class c1 = Class。forName（“com。zj。demotest。domain。Person”）；Constructor
結果：
吃飯
注意：setAccessible（）方法能在執行時
壓制
Java語言訪問控制檢查（Java language access control checks），從而能任意呼叫
被私有化
保護的方法、域和構造方法。
由此我們可以發現** 單例模式不再安全，反射可破之！**
訪問屬性
Field getField(name)
根據欄位名獲取某個public的field（包括父類）
Field getDeclaredField（name）
根據欄位名獲取當前類的某個field（不包括父類）
Field［］ getFields（）
獲取所有public的field（包括父類）
Field［］ getDeclaredFields（）
獲取當前類的所有field（不包括父類）
我們來看一個例子：
public class TestReflection3 { public static void main（String［］ args） throws Exception { Object p = new Student（“li hua”）； Class c = p。getClass（）； Field f = c。getDeclaredField（“name”）；//獲取屬性 f。setAccessible（true）；//允許訪問 Object val= f。get（p）； System。out。println（val）； } static class Student { private String name； public Student（String name） { this。name = name； } }}
結果：
li hua
我們可以發現
反射可以破壞類的封裝
呼叫方法
Method getMethod(name, Class...)
獲取某個public的Method（包括父類）
Method getDeclaredMethod（name， Class。。。）
獲取當前類的某個Method（不包括父類）
Method［］ getMethods（）
獲取所有public的Method（包括父類）
Method［］ getDeclaredMethods（）
獲取當前類的所有Method（不包括父類）
我們來看一個例子：
public class TestReflection4 { public static void main（String［］ args） throws Exception { //獲取私有方法，需要傳參：方法名和引數 Method h = Student。class。getDeclaredMethod（“setName”，String。class）； h。setAccessible（true）； Student s1 =new Student（）； System。out。println（s1。name）； //傳入目標物件，呼叫對應的方法 h。invoke（s1，“xiao ming”）； System。out。println（s1。name）； } static class Student { private String name； private void setName（String name） { this。name = name； } }}
結果：
null xiao ming
我們發現獲取方法getMethod（）時，需要傳參
方法名和引數
這是因為。class檔案中通常有
不止一個方法
，獲取方法getMethod（）時，會去呼叫searchMethods方法迴圈遍歷所有Method，然後根據
方法名和引數型別
找到唯一符合的Method返回。
我們知道類的方法是在JVM的方法區中 ，當我們new 多個物件時，屬性會另外開闢堆空間存放，而方法只有一份，不會額外消耗記憶體，方法就像一套指令模板，誰都可以傳入資料交給它執行，然後得到對應執行結果。
method。invoke（obj， args）
時傳入目標物件，即可呼叫對應物件的方法
如果獲取到的Method表示一個靜態方法，呼叫靜態方法時，
無需指定例項物件
，所以invoke方法傳入的第一個引數永遠為null，
method。invoke（null， args）
那如果 方法重寫了呢，
反射依舊遵循 多型 的原則
。
反射的應用場景
如果平時我們只是寫業務程式碼，很少會接觸到直接使用反射機制的場景，畢竟我們可以直接new一個物件，效能比還反射要高。
但如果我們是工具框架的開發者，那一定非常熟悉，像 Spring/Spring Boot、MyBatis 等等框架中都大量使用反射機制，
反射被稱為框架的靈魂
比如：
Mybatis Plus可以讓我們只寫介面，不寫實現類，就可以執行SQL
開發專案時，切換不同的資料庫只需更改配置檔案即可
類上加上@Component註解，Spring就幫我們建立物件
在Spring我們只需 @Value註解就讀取到配置檔案中的值
等等
擴充套件：反射配置檔案
我們來模擬一個配置高於編碼的例子
新建my。properties，將其放在resources的目錄下
#Person類的包路徑className=com。zj。demotest。domain。Person methodName=eat
Person類 還是本文 一直用的，在文章的開頭有
最後我們來編寫一個測試類
public class TestProp { public static void main（String［］ args） throws IOException， ClassNotFoundException， IllegalAccessException， InstantiationException， NoSuchMethodException， InvocationTargetException { Properties properties = new Properties（）； ClassLoader classLoader = TestProp。class。getClassLoader（）； InputStream inputStream = classLoader。getResourceAsStream（“my。properties”）；// 載入配置檔案 properties。load（inputStream）； String className = properties。getProperty（“className”）； System。out。println（“配置檔案中的內容：className=”+className）； String methodName = properties。getProperty（“methodName”）； System。out。println（“配置檔案中的內容：methodName=”+methodName）； Class name = Class。forName（className）； Object object = name。newInstance（）； Method method = name。getMethod（methodName）； method。invoke（object）； }}
結果：
配置檔案中的內容：className=com。zj。demotest。domain。Person
配置檔案中的內容：methodName=eat
吃飯
緊接著，我們修改配置檔案：
className=com。zj。demotest。domain。PersonmethodName=eat
結果變為：
配置檔案中的內容：className=com。zj。demotest。domain。Person
配置檔案中的內容：methodName=Dance
跳舞
是不是很方便？
尾語
反射機制是一種功能強大的機制，讓Java程式具有在
執行期
分析類以及修改其本身狀態或行為的能力
。
對於特定的複雜系統程式設計任務，它是非常必要的，為各種框架提供開箱即用的功能提供了便利，為解耦合提供了保障機制。
但是世事無絕對，反射相當於一系列解釋操作，通知 JVM 要做的事情，效能比直接訪問物件要差點（JIT最佳化後，對於框架來說實際是影響不大的），還會增加程式的複雜性等（明明直接new一下就能解決的事情，非要寫一大段程式碼）。
