深入理解Java类型信息(Class对象)与反射机制
關(guān)聯(lián)文章：
深入理解Java類型信息(Class對象)與反射機(jī)制
深入理解Java枚舉類型(enum)
深入理解Java注解類型(@Annotation)
深入理解Java并發(fā)之synchronized實(shí)現(xiàn)原理
深入理解Java內(nèi)存模型(JMM)及volatile關(guān)鍵字
深入理解Java類加載器(ClassLoader)
本篇主要是深入對Java中的Class對象進(jìn)行分析，這對后續(xù)深入理解反射技術(shù)非常重要，主要內(nèi)容如下：
- 深入理解Class對象
- RRTI的概念以及Class對象作用
- Class對象的加載及其獲取方式
- Class對象的加載
- ClassforName方法
- Class字面常量
- 理解泛化的Class對象引用
- 關(guān)于類型轉(zhuǎn)換的問題
- instanceof 關(guān)鍵字與isInstance方法
- 理解反射技術(shù)
- Constructor類及其用法
- Field類及其用法
- Method類及其用法
- 反射包中的Array類
深入理解Class對象
RRTI的概念以及Class對象作用
認(rèn)識Class對象之前，先來了解一個(gè)概念，RTTI（Run-Time Type Identification）運(yùn)行時(shí)類型識別，對于這個(gè)詞一直是 C++ 中的概念，至于Java中出現(xiàn)RRTI的說法則是源于《Thinking in Java》一書，其作用是在運(yùn)行時(shí)識別一個(gè)對象的類型和類的信息，這里分兩種：傳統(tǒng)的”RRTI”,它假定我們在編譯期已知道了所有類型(在沒有反射機(jī)制創(chuàng)建和使用類對象時(shí)，一般都是編譯期已確定其類型，如new對象時(shí)該類必須已定義好)，另外一種是反射機(jī)制，它允許我們在運(yùn)行時(shí)發(fā)現(xiàn)和使用類型的信息。在Java中用來表示運(yùn)行時(shí)類型信息的對應(yīng)類就是Class類，Class類也是一個(gè)實(shí)實(shí)在在的類，存在于JDK的java.lang包中，其部分源碼如下：
public final class Class<T> implements java.io.Serializable,GenericDeclaration,Type, AnnotatedElement {private static final int ANNOTATION= 0x00002000;private static final int ENUM = 0x00004000;private static final int SYNTHETIC = 0x00001000;private static native void registerNatives();static {registerNatives();}/** Private constructor. Only the Java Virtual Machine creates Class objects.（私有構(gòu)造，只能由JVM創(chuàng)建該類）* This constructor is not used and prevents the default constructor being* generated.*/private Class(ClassLoader loader) {// Initialize final field for classLoader. The initialization value of non-null// prevents future JIT optimizations from assuming this final field is null.classLoader = loader;}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
Class類被創(chuàng)建后的對象就是Class對象，注意，Class對象表示的是自己手動編寫類的類型信息，比如創(chuàng)建一個(gè)Shapes類，那么，JVM就會創(chuàng)建一個(gè)Shapes對應(yīng)Class類的Class對象，該Class對象保存了Shapes類相關(guān)的類型信息。實(shí)際上在Java中每個(gè)類都有一個(gè)Class對象，每當(dāng)我們編寫并且編譯一個(gè)新創(chuàng)建的類就會產(chǎn)生一個(gè)對應(yīng)Class對象并且這個(gè)Class對象會被保存在同名.class文件里(編譯后的字節(jié)碼文件保存的就是Class對象)，那為什么需要這樣一個(gè)Class對象呢？是這樣的，當(dāng)我們new一個(gè)新對象或者引用靜態(tài)成員變量時(shí)，Java虛擬機(jī)(JVM)中的類加載器子系統(tǒng)會將對應(yīng)Class對象加載到JVM中，然后JVM再根據(jù)這個(gè)類型信息相關(guān)的Class對象創(chuàng)建我們需要實(shí)例對象或者提供靜態(tài)變量的引用值。需要特別注意的是，手動編寫的每個(gè)class類，無論創(chuàng)建多少個(gè)實(shí)例對象，在JVM中都只有一個(gè)Class對象，即在內(nèi)存中每個(gè)類有且只有一個(gè)相對應(yīng)的Class對象，挺拗口，通過下圖理解（內(nèi)存中的簡易現(xiàn)象圖）：
到這我們也就可以得出以下幾點(diǎn)信息：
Class類也是類的一種，與class關(guān)鍵字是不一樣的。
手動編寫的類被編譯后會產(chǎn)生一個(gè)Class對象，其表示的是創(chuàng)建的類的類型信息，而且這個(gè)Class對象保存在同名.class的文件中(字節(jié)碼文件)，比如創(chuàng)建一個(gè)Shapes類，編譯Shapes類后就會創(chuàng)建其包含Shapes類相關(guān)類型信息的Class對象，并保存在Shapes.class字節(jié)碼文件中。
每個(gè)通過關(guān)鍵字class標(biāo)識的類，在內(nèi)存中有且只有一個(gè)與之對應(yīng)的Class對象來描述其類型信息，無論創(chuàng)建多少個(gè)實(shí)例對象，其依據(jù)的都是用一個(gè)Class對象。
Class類只存私有構(gòu)造函數(shù)，因此對應(yīng)Class對象只能有JVM創(chuàng)建和加載
Class類的對象作用是運(yùn)行時(shí)提供或獲得某個(gè)對象的類型信息，這點(diǎn)對于反射技術(shù)很重要(關(guān)于反射稍后分析)。
Class對象的加載及其獲取方式
Class對象的加載
前面我們已提到過，Class對象是由JVM加載的，那么其加載時(shí)機(jī)是？實(shí)際上所有的類都是在對其第一次使用時(shí)動態(tài)加載到JVM中的，當(dāng)程序創(chuàng)建第一個(gè)對類的靜態(tài)成員引用時(shí)，就會加載這個(gè)被使用的類(實(shí)際上加載的就是這個(gè)類的字節(jié)碼文件)，注意，使用new操作符創(chuàng)建類的新實(shí)例對象也會被當(dāng)作對類的靜態(tài)成員的引用(構(gòu)造函數(shù)也是類的靜態(tài)方法)，由此看來Java程序在它們開始運(yùn)行之前并非被完全加載到內(nèi)存的，其各個(gè)部分是按需加載，所以在使用該類時(shí)，類加載器首先會檢查這個(gè)類的Class對象是否已被加載(類的實(shí)例對象創(chuàng)建時(shí)依據(jù)Class對象中類型信息完成的)，如果還沒有加載，默認(rèn)的類加載器就會先根據(jù)類名查找.class文件(編譯后Class對象被保存在同名的.class文件中)，在這個(gè)類的字節(jié)碼文件被加載時(shí)，它們必須接受相關(guān)驗(yàn)證，以確保其沒有被破壞并且不包含不良Java代碼(這是java的安全機(jī)制檢測)，完全沒有問題后就會被動態(tài)加載到內(nèi)存中，此時(shí)相當(dāng)于Class對象也就被載入內(nèi)存了(畢竟.class字節(jié)碼文件保存的就是Class對象)，同時(shí)也就可以被用來創(chuàng)建這個(gè)類的所有實(shí)例對象。下面通過一個(gè)簡單例子來說明Class對象被加載的時(shí)機(jī)問題（例子引用自Thinking in Java）：
package com.zejian;class Candy {static { System.out.println("Loading Candy"); } }class Gum {static { System.out.println("Loading Gum"); } }class Cookie {static { System.out.println("Loading Cookie"); } }public class SweetShop {public static void print(Object obj) {System.out.println(obj);}public static void main(String[] args) { print("inside main");new Candy();print("After creating Candy");try {Class.forName("com.zejian.Gum");} catch(ClassNotFoundException e) {print("Couldn't find Gum");}print("After Class.forName(\"com.zejian.Gum\")");new Cookie();print("After creating Cookie");} }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
在上述代碼中,每個(gè)類Candy、Gum、Cookie都存在一個(gè)static語句，這個(gè)語句會在類第一次被加載時(shí)執(zhí)行，這個(gè)語句的作用就是告訴我們該類在什么時(shí)候被加載，執(zhí)行結(jié)果：
inside main Loading Candy After creating Candy Loading Gum After Class.forName("com.zejian.Gum") Loading Cookie After creating CookieProcess finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
從結(jié)果來看，new一個(gè)Candy對象和Cookie對象，構(gòu)造函數(shù)將被調(diào)用，屬于靜態(tài)方法的引用，Candy類的Class對象和Cookie的Class對象肯定會被加載，畢竟Candy實(shí)例對象的創(chuàng)建依據(jù)其Class對象。比較有意思的是
Class.forName("com.zejian.Gum");- 1
其中forName方法是Class類的一個(gè)static成員方法，記住所有的Class對象都源于這個(gè)Class類，因此Class類中定義的方法將適應(yīng)所有Class對象。這里通過forName方法，我們可以獲取到Gum類對應(yīng)的Class對象引用。從打印結(jié)果來看，調(diào)用forName方法將會導(dǎo)致Gum類被加載(前提是Gum類從來沒有被加載過)。
Class.forName方法
通過上述的案例，我們也就知道Class.forName()方法的調(diào)用將會返回一個(gè)對應(yīng)類的Class對象，因此如果我們想獲取一個(gè)類的運(yùn)行時(shí)類型信息并加以使用時(shí)，可以調(diào)用Class.forName()方法獲取Class對象的引用，這樣做的好處是無需通過持有該類的實(shí)例對象引用而去獲取Class對象，如下的第2種方式是通過一個(gè)實(shí)例對象獲取一個(gè)類的Class對象，其中的getClass()是從頂級類Object繼承而來的，它將返回表示該對象的實(shí)際類型的Class對象引用。
public static void main(String[] args) {try{//通過Class.forName獲取Gum類的Class對象Class clazz=Class.forName("com.zejian.Gum");System.out.println("forName=clazz:"+clazz.getName());}catch (ClassNotFoundException e){e.printStackTrace();}//通過實(shí)例對象獲取Gum的Class對象Gum gum = new Gum();Class clazz2=gum.getClass();System.out.println("new=clazz2:"+clazz2.getName());}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
注意調(diào)用forName方法時(shí)需要捕獲一個(gè)名稱為ClassNotFoundException的異常，因?yàn)閒orName方法在編譯器是無法檢測到其傳遞的字符串對應(yīng)的類是否存在的，只能在程序運(yùn)行時(shí)進(jìn)行檢查，如果不存在就會拋出ClassNotFoundException異常。
Class字面常量
在Java中存在另一種方式來生成Class對象的引用，它就是Class字面常量，如下：
//字面常量的方式獲取Class對象 Class clazz = Gum.class;- 1
- 2
這種方式相對前面兩種方法更加簡單，更安全。因?yàn)樗诰幾g器就會受到編譯器的檢查同時(shí)由于無需調(diào)用forName方法效率也會更高，因?yàn)橥ㄟ^字面量的方法獲取Class對象的引用不會自動初始化該類。更加有趣的是字面常量的獲取Class對象引用方式不僅可以應(yīng)用于普通的類，也可以應(yīng)用用接口，數(shù)組以及基本數(shù)據(jù)類型，這點(diǎn)在反射技術(shù)應(yīng)用傳遞參數(shù)時(shí)很有幫助，關(guān)于反射技術(shù)稍后會分析，由于基本數(shù)據(jù)類型還有對應(yīng)的基本包裝類型，其包裝類型有一個(gè)標(biāo)準(zhǔn)字段TYPE，而這個(gè)TYPE就是一個(gè)引用，指向基本數(shù)據(jù)類型的Class對象，其等價(jià)轉(zhuǎn)換如下，一般情況下更傾向使用.class的形式，這樣可以保持與普通類的形式統(tǒng)一。
boolean.class = Boolean.TYPE; char.class = Character.TYPE; byte.class = Byte.TYPE; short.class = Short.TYPE; int.class = Integer.TYPE; long.class = Long.TYPE; float.class = Float.TYPE; double.class = Double.TYPE; void.class = Void.TYPE;- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
前面提到過，使用字面常量的方式獲取Class對象的引用不會觸發(fā)類的初始化，這里我們可能需要簡單了解一下類加載的過程，如下：
加載：類加載過程的一個(gè)階段：通過一個(gè)類的完全限定查找此類字節(jié)碼文件，并利用字節(jié)碼文件創(chuàng)建一個(gè)Class對象
鏈接：驗(yàn)證字節(jié)碼的安全性和完整性，準(zhǔn)備階段正式為靜態(tài)域分配存儲空間，注意此時(shí)只是分配靜態(tài)成員變量的存儲空間，不包含實(shí)例成員變量，如果必要的話，解析這個(gè)類創(chuàng)建的對其他類的所有引用。
初始化：類加載最后階段，若該類具有超類，則對其進(jìn)行初始化，執(zhí)行靜態(tài)初始化器和靜態(tài)初始化成員變量。
由此可知，我們獲取字面常量的Class引用時(shí)，觸發(fā)的應(yīng)該是加載階段，因?yàn)樵谶@個(gè)階段Class對象已創(chuàng)建完成，獲取其引用并不困難，而無需觸發(fā)類的最后階段初始化。下面通過小例子來驗(yàn)證這個(gè)過程：
import java.util.*;class Initable {//編譯期靜態(tài)常量static final int staticFinal = 47;//非編期靜態(tài)常量static final int staticFinal2 =ClassInitialization.rand.nextInt(1000);static {System.out.println("Initializing Initable");} }class Initable2 {//靜態(tài)成員變量static int staticNonFinal = 147;static {System.out.println("Initializing Initable2");} }class Initable3 {//靜態(tài)成員變量static int staticNonFinal = 74;static {System.out.println("Initializing Initable3");} }public class ClassInitialization {public static Random rand = new Random(47);public static void main(String[] args) throws Exception {//字面常量獲取方式獲取Class對象Class initable = Initable.class;System.out.println("After creating Initable ref");//不觸發(fā)類初始化System.out.println(Initable.staticFinal);//會觸發(fā)類初始化System.out.println(Initable.staticFinal2);//會觸發(fā)類初始化System.out.println(Initable2.staticNonFinal);//forName方法獲取Class對象Class initable3 = Class.forName("Initable3");System.out.println("After creating Initable3 ref");System.out.println(Initable3.staticNonFinal);} }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
執(zhí)行結(jié)果：
After creating Initable ref 47 Initializing Initable 258 Initializing Initable2 147 Initializing Initable3 After creating Initable3 ref 74- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
從輸出結(jié)果來看，可以發(fā)現(xiàn)，通過字面常量獲取方式獲取Initable類的Class對象并沒有觸發(fā)Initable類的初始化，這點(diǎn)也驗(yàn)證了前面的分析，同時(shí)發(fā)現(xiàn)調(diào)用Initable.staticFinal變量時(shí)也沒有觸發(fā)初始化，這是因?yàn)閟taticFinal屬于編譯期靜態(tài)常量，在編譯階段通過常量傳播優(yōu)化的方式將Initable類的常量staticFinal存儲到了一個(gè)稱為NotInitialization類的常量池中，在以后對Initable類常量staticFinal的引用實(shí)際都轉(zhuǎn)化為對NotInitialization類對自身常量池的引用，所以在編譯期后，對編譯期常量的引用都將在NotInitialization類的常量池獲取，這也就是引用編譯期靜態(tài)常量不會觸發(fā)Initable類初始化的重要原因。但在之后調(diào)用了Initable.staticFinal2變量后就觸發(fā)了Initable類的初始化，注意staticFinal2雖然被static和final修飾，但其值在編譯期并不能確定，因此staticFinal2并不是編譯期常量，使用該變量必須先初始化Initable類。Initable2和Initable3類中都是靜態(tài)成員變量并非編譯期常量，引用都會觸發(fā)初始化。至于forName方法獲取Class對象，肯定會觸發(fā)初始化，這點(diǎn)在前面已分析過。到這幾種獲取Class對象的方式也都分析完，ok~,到此這里可以得出小結(jié)論：
獲取Class對象引用的方式3種，通過繼承自O(shè)bject類的getClass方法，Class類的靜態(tài)方法forName以及字面常量的方式”.class”。
其中實(shí)例類的getClass方法和Class類的靜態(tài)方法forName都將會觸發(fā)類的初始化階段，而字面常量獲取Class對象的方式則不會觸發(fā)初始化。
初始化是類加載的最后一個(gè)階段，也就是說完成這個(gè)階段后類也就加載到內(nèi)存中(Class對象在加載階段已被創(chuàng)建)，此時(shí)可以對類進(jìn)行各種必要的操作了（如new對象，調(diào)用靜態(tài)成員等），注意在這個(gè)階段，才真正開始執(zhí)行類中定義的Java程序代碼或者字節(jié)碼。
關(guān)于類加載的初始化階段，在虛擬機(jī)規(guī)范嚴(yán)格規(guī)定了有且只有5種場景必須對類進(jìn)行初始化：
使用new關(guān)鍵字實(shí)例化對象時(shí)、讀取或者設(shè)置一個(gè)類的靜態(tài)字段(不包含編譯期常量)以及調(diào)用靜態(tài)方法的時(shí)候，必須觸發(fā)類加載的初始化過程(類加載過程最終階段)。
使用反射包(java.lang.reflect)的方法對類進(jìn)行反射調(diào)用時(shí)，如果類還沒有被初始化，則需先進(jìn)行初始化，這點(diǎn)對反射很重要。
當(dāng)初始化一個(gè)類的時(shí)候，如果其父類還沒進(jìn)行初始化則需先觸發(fā)其父類的初始化。
當(dāng)Java虛擬機(jī)啟動時(shí)，用戶需要指定一個(gè)要執(zhí)行的主類(包含main方法的類)，虛擬機(jī)會先初始化這個(gè)主類
當(dāng)使用JDK 1.7 的動態(tài)語言支持時(shí)，如果一個(gè)java.lang.invoke.MethodHandle 實(shí)例最后解析結(jié)果為REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且這個(gè)方法句柄對應(yīng)類沒有初始化時(shí)，必須觸發(fā)其初始化(這點(diǎn)看不懂就算了，這是1.7的新增的動態(tài)語言支持，其關(guān)鍵特征是它的類型檢查的主體過程是在運(yùn)行期而不是編譯期進(jìn)行的，這是一個(gè)比較大點(diǎn)的話題，這里暫且打住)
理解泛化的Class對象引用
由于Class的引用總數(shù)指向某個(gè)類的Class對象，利用Class對象可以創(chuàng)建實(shí)例類，這也就足以說明Class對象的引用指向的對象確切的類型。在Java SE5引入泛型后，使用我們可以利用泛型來表示Class對象更具體的類型，即使在運(yùn)行期間會被擦除，但編譯期足以確保我們使用正確的對象類型。如下：
/*** Created by zejian on 2017/4/30.* Blog : http://blog.csdn.net/javazejian [原文地址,請尊重原創(chuàng)]*/ public class ClazzDemo {public static void main(String[] args){//沒有泛型Class intClass = int.class;//帶泛型的Class對象Class<Integer> integerClass = int.class;integerClass = Integer.class;//沒有泛型的約束,可以隨意賦值intClass= double.class;//編譯期錯(cuò)誤,無法編譯通過//integerClass = double.class} }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
從代碼可以看出，聲明普通的Class對象，在編譯器并不會檢查Class對象的確切類型是否符合要求，如果存在錯(cuò)誤只有在運(yùn)行時(shí)才得以暴露出來。但是通過泛型聲明指明類型的Class對象，編譯器在編譯期將對帶泛型的類進(jìn)行額外的類型檢查，確保在編譯期就能保證類型的正確性，實(shí)際上Integer.class就是一個(gè)Class<Integer>類的對象。面對下述語句，確實(shí)可能令人困惑，但該語句確實(shí)是無法編譯通過的。
//編譯無法通過 Class<Number> numberClass=Integer.class;- 1
- 2
我們或許會想Integer不就是Number的子類嗎？然而事實(shí)并非這般簡單，畢竟Integer的Class對象并非Number的Class對象的子類，前面提到過，所有的Class對象都只來源于Class類，看來事實(shí)確實(shí)如此。當(dāng)然我們可以利用通配符“?”來解決問題：
Class<?> intClass = int.class; intClass = double.class;- 1
- 2
這樣的語句并沒有什么問題，畢竟通配符指明所有類型都適用，那么為什么不直接使用Class還要使用Class<?>呢？這樣做的好處是告訴編譯器，我們是確實(shí)是采用任意類型的泛型，而非忘記使用泛型約束，因此Class<?>總是優(yōu)于直接使用Class，至少前者在編譯器檢查時(shí)不會產(chǎn)生警告信息。當(dāng)然我們還可以使用extends關(guān)鍵字告訴編譯器接收某個(gè)類型的子類，如解決前面Number與Integer的問題：
//編譯通過！ Class<? extends Number> clazz = Integer.class; //賦予其他類型 clazz = double.class; clazz = Number.class;- 1
- 2
- 3
- 4
- 5
上述的代碼是行得通的，extends關(guān)鍵字的作用是告訴編譯器，只要是Number的子類都可以賦值。這點(diǎn)與前面直接使用Class<Number>是不一樣的。實(shí)際上，應(yīng)該時(shí)刻記住向Class引用添加泛型約束僅僅是為了提供編譯期類型的檢查從而避免將錯(cuò)誤延續(xù)到運(yùn)行時(shí)期。
關(guān)于類型轉(zhuǎn)換的問題
在許多需要強(qiáng)制類型轉(zhuǎn)換的場景，我們更多的做法是直接強(qiáng)制轉(zhuǎn)換類型：
package com.zejian;/*** Created by zejian on 2017/4/30.* Blog : http://blog.csdn.net/javazejian [原文地址,請尊重原創(chuàng)]*/ public class ClassCast {public void cast(){Animal animal= new Dog();//強(qiáng)制轉(zhuǎn)換Dog dog = (Dog) animal;} }interface Animal{ }class Dog implements Animal{ }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
之所可以強(qiáng)制轉(zhuǎn)換，這得歸功于RRTI，要知道在Java中，所有類型轉(zhuǎn)換都是在運(yùn)行時(shí)進(jìn)行正確性檢查的，利用RRTI進(jìn)行判斷類型是否正確從而確保強(qiáng)制轉(zhuǎn)換的完成，如果類型轉(zhuǎn)換失敗，將會拋出類型轉(zhuǎn)換異常。除了強(qiáng)制轉(zhuǎn)換外，在Java SE5中新增一種使用Class對象進(jìn)行類型轉(zhuǎn)換的方式，如下：
Animal animal= new Dog(); //這兩句等同于Dog dog = (Dog) animal; Class<Dog> dogType = Dog.class; Dog dog = dogType.cast(animal)- 1
- 2
- 3
- 4
利用Class對象的cast方法，其參數(shù)接收一個(gè)參數(shù)對象并將其轉(zhuǎn)換為Class引用的類型。這種方式似乎比之前的強(qiáng)制轉(zhuǎn)換更麻煩些，確實(shí)如此，而且當(dāng)類型不能正確轉(zhuǎn)換時(shí)，仍然會拋出ClassCastException異常。源碼如下：
public T cast(Object obj) {if (obj != null && !isInstance(obj))throw new ClassCastException(cannotCastMsg(obj));return (T) obj;}- 1
- 2
- 3
- 4
- 5
instanceof 關(guān)鍵字與isInstance方法
關(guān)于instanceof 關(guān)鍵字，它返回一個(gè)boolean類型的值，意在告訴我們對象是不是某個(gè)特定的類型實(shí)例。如下，在強(qiáng)制轉(zhuǎn)換前利用instanceof檢測obj是不是Animal類型的實(shí)例對象，如果返回true再進(jìn)行類型轉(zhuǎn)換，這樣可以避免拋出類型轉(zhuǎn)換的異常(ClassCastException)
public void cast2(Object obj){if(obj instanceof Animal){Animal animal= (Animal) obj;} }- 1
- 2
- 3
- 4
- 5
而isInstance方法則是Class類中的一個(gè)Native方法，也是用于判斷對象類型的，看個(gè)簡單例子：
public void cast2(Object obj){//instanceof關(guān)鍵字if(obj instanceof Animal){Animal animal= (Animal) obj;}//isInstance方法if(Animal.class.isInstance(obj)){Animal animal= (Animal) obj;}}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
事實(shí)上instanceOf 與isInstance方法產(chǎn)生的結(jié)果是相同的。對于instanceOf是關(guān)鍵字只被用于對象引用變量，檢查左邊對象是不是右邊類或接口的實(shí)例化。如果被測對象是null值，則測試結(jié)果總是false。一般形式：
//判斷這個(gè)對象是不是這種類型 obj.instanceof(class)- 1
- 2
而isInstance方法則是Class類的Native方法，其中obj是被測試的對象或者變量，如果obj是調(diào)用這個(gè)方法的class或接口的實(shí)例，則返回true。如果被檢測的對象是null或者基本類型，那么返回值是false;一般形式如下：
//判斷這個(gè)對象能不能被轉(zhuǎn)化為這個(gè)類 class.inInstance(obj)- 1
- 2
最后這里給出一個(gè)簡單實(shí)例，驗(yàn)證isInstance方法與instanceof等價(jià)性：
class A {}class B extends A {}public class C {static void test(Object x) {print("Testing x of type " + x.getClass());print("x instanceof A " + (x instanceof A));print("x instanceof B "+ (x instanceof B));print("A.isInstance(x) "+ A.class.isInstance(x));print("B.isInstance(x) " +B.class.isInstance(x));print("x.getClass() == A.class " +(x.getClass() == A.class));print("x.getClass() == B.class " +(x.getClass() == B.class));print("x.getClass().equals(A.class)) "+(x.getClass().equals(A.class)));print("x.getClass().equals(B.class)) " +(x.getClass().equals(B.class)));}public static void main(String[] args) {test(new A());test(new B());} }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
執(zhí)行結(jié)果：
Testing x of type class com.zejian.A x instanceof A true x instanceof B false //父類不一定是子類的某個(gè)類型 A.isInstance(x) true B.isInstance(x) false x.getClass() == A.class true x.getClass() == B.class false x.getClass().equals(A.class)) true x.getClass().equals(B.class)) false --------------------------------------------- Testing x of type class com.zejian.B x instanceof A true x instanceof B true A.isInstance(x) true B.isInstance(x) true x.getClass() == A.class false x.getClass() == B.class true x.getClass().equals(A.class)) false x.getClass().equals(B.class)) true- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
到此關(guān)于Class對象相關(guān)的知識點(diǎn)都分析完了，下面將結(jié)合Class對象的知識點(diǎn)分析反射技術(shù)。
理解反射技術(shù)
反射機(jī)制是在運(yùn)行狀態(tài)中，對于任意一個(gè)類，都能夠知道這個(gè)類的所有屬性和方法；對于任意一個(gè)對象，都能夠調(diào)用它的任意一個(gè)方法和屬性，這種動態(tài)獲取的信息以及動態(tài)調(diào)用對象的方法的功能稱為java語言的反射機(jī)制。一直以來反射技術(shù)都是Java中的閃亮點(diǎn)，這也是目前大部分框架(如Spring/Mybatis等)得以實(shí)現(xiàn)的支柱。在Java中，Class類與java.lang.reflect類庫一起對反射技術(shù)進(jìn)行了全力的支持。在反射包中，我們常用的類主要有Constructor類表示的是Class 對象所表示的類的構(gòu)造方法，利用它可以在運(yùn)行時(shí)動態(tài)創(chuàng)建對象、Field表示Class對象所表示的類的成員變量，通過它可以在運(yùn)行時(shí)動態(tài)修改成員變量的屬性值(包含private)、Method表示Class對象所表示的類的成員方法，通過它可以動態(tài)調(diào)用對象的方法(包含private)，下面將對這幾個(gè)重要類進(jìn)行分別說明。
Constructor類及其用法
Constructor類存在于反射包(java.lang.reflect)中，反映的是Class 對象所表示的類的構(gòu)造方法。獲取Constructor對象是通過Class類中的方法獲取的，Class類與Constructor相關(guān)的主要方法如下：
| static Class<?> | forName(String className) | 返回與帶有給定字符串名的類或接口相關(guān)聯(lián)的 Class 對象。 |
| Constructor<T> | getConstructor(Class<?>... parameterTypes) | 返回指定參數(shù)類型、具有public訪問權(quán)限的構(gòu)造函數(shù)對象 |
| Constructor<?>[] | getConstructors() | 返回所有具有public訪問權(quán)限的構(gòu)造函數(shù)的Constructor對象數(shù)組 |
| Constructor<T> | getDeclaredConstructor(Class<?>... parameterTypes) | 返回指定參數(shù)類型、所有聲明的（包括private）構(gòu)造函數(shù)對象 |
| Constructor<?>[] | getDeclaredConstructor() | 返回所有聲明的（包括private）構(gòu)造函數(shù)對象 |
| T | newInstance() | 創(chuàng)建此 Class 對象所表示的類的一個(gè)新實(shí)例。 |
下面看一個(gè)簡單例子來了解Constructor對象的使用：
package reflect;import java.io.Serializable; import java.lang.reflect.Constructor;/*** Created by zejian on 2017/5/1.* Blog : http://blog.csdn.net/javazejian [原文地址,請尊重原創(chuàng)]*/ public class ReflectDemo implements Serializable{public static void main(String[] args) throws Exception {Class<?> clazz = null;//獲取Class對象的引用clazz = Class.forName("reflect.User");//第一種方法，實(shí)例化默認(rèn)構(gòu)造方法，User必須無參構(gòu)造函數(shù),否則將拋異常User user = (User) clazz.newInstance();user.setAge(20);user.setName("Rollen");System.out.println(user);System.out.println("--------------------------------------------");//獲取帶String參數(shù)的public構(gòu)造函數(shù)Constructor cs1 =clazz.getConstructor(String.class);//創(chuàng)建UserUser user1= (User) cs1.newInstance("xiaolong");user1.setAge(22);System.out.println("user1:"+user1.toString());System.out.println("--------------------------------------------");//取得指定帶int和String參數(shù)構(gòu)造函數(shù),該方法是私有構(gòu)造privateConstructor cs2=clazz.getDeclaredConstructor(int.class,String.class);//由于是private必須設(shè)置可訪問cs2.setAccessible(true);//創(chuàng)建user對象User user2= (User) cs2.newInstance(25,"lidakang");System.out.println("user2:"+user2.toString());System.out.println("--------------------------------------------");//獲取所有構(gòu)造包含privateConstructor<?> cons[] = clazz.getDeclaredConstructors();// 查看每個(gè)構(gòu)造方法需要的參數(shù)for (int i = 0; i < cons.length; i++) {//獲取構(gòu)造函數(shù)參數(shù)類型Class<?> clazzs[] = cons[i].getParameterTypes();System.out.println("構(gòu)造函數(shù)["+i+"]:"+cons[i].toString() );System.out.print("參數(shù)類型["+i+"]:(");for (int j = 0; j < clazzs.length; j++) {if (j == clazzs.length - 1)System.out.print(clazzs[j].getName());elseSystem.out.print(clazzs[j].getName() + ",");}System.out.println(")");}} }class User {private int age;private String name;public User() {super();}public User(String name) {super();this.name = name;}/*** 私有構(gòu)造* @param age* @param name*/private User(int age, String name) {super();this.age = age;this.name = name;}//..........省略set 和 get方法 }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
運(yùn)行結(jié)果：
User [age=20, name=Rollen] -------------------------------------------- user1:User [age=22, name=xiaolong] -------------------------------------------- user2:User [age=25, name=lidakang] -------------------------------------------- 構(gòu)造函數(shù)[0]:private reflect.User(int,java.lang.String) 參數(shù)類型[0]:(int,java.lang.String) 構(gòu)造函數(shù)[1]:public reflect.User(java.lang.String) 參數(shù)類型[1]:(java.lang.String) 構(gòu)造函數(shù)[2]:public reflect.User() 參數(shù)類型[2]:()- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
關(guān)于Constructor類本身一些常用方法如下(僅部分，其他可查API)，
| Class<T> | getDeclaringClass() | 返回 Class 對象，該對象表示聲明由此 Constructor 對象表示的構(gòu)造方法的類,其實(shí)就是返回真實(shí)類型（不包含參數(shù)） |
| Type[] | getGenericParameterTypes() | 按照聲明順序返回一組 Type 對象，返回的就是 Constructor對象構(gòu)造函數(shù)的形參類型。 |
| String | getName() | 以字符串形式返回此構(gòu)造方法的名稱。 |
| Class<?>[] | getParameterTypes() | 按照聲明順序返回一組 Class 對象，即返回Constructor 對象所表示構(gòu)造方法的形參類型 |
| T | newInstance(Object... initargs) | 使用此 Constructor對象表示的構(gòu)造函數(shù)來創(chuàng)建新實(shí)例 |
| String | toGenericString() | 返回描述此 Constructor 的字符串，其中包括類型參數(shù)。 |
代碼演示如下：
Constructor cs3=clazz.getDeclaredConstructor(int.class,String.class);System.out.println("-----getDeclaringClass-----"); Class uclazz=cs3.getDeclaringClass(); //Constructor對象表示的構(gòu)造方法的類 System.out.println("構(gòu)造方法的類:"+uclazz.getName());System.out.println("-----getGenericParameterTypes-----"); //對象表示此 Constructor 對象所表示的方法的形參類型 Type[] tps=cs3.getGenericParameterTypes(); for (Type tp:tps) {System.out.println("參數(shù)名稱tp:"+tp); } System.out.println("-----getParameterTypes-----"); //獲取構(gòu)造函數(shù)參數(shù)類型 Class<?> clazzs[] = cs3.getParameterTypes(); for (Class claz:clazzs) {System.out.println("參數(shù)名稱:"+claz.getName()); } System.out.println("-----getName-----"); //以字符串形式返回此構(gòu)造方法的名稱 System.out.println("getName:"+cs3.getName());System.out.println("-----getoGenericString-----"); //返回描述此 Constructor 的字符串，其中包括類型參數(shù)。 System.out.println("getoGenericString():"+cs3.toGenericString()); /**輸出結(jié)果:-----getDeclaringClass-----構(gòu)造方法的類:reflect.User-----getGenericParameterTypes-----參數(shù)名稱tp:int參數(shù)名稱tp:class java.lang.String-----getParameterTypes-----參數(shù)名稱:int參數(shù)名稱:java.lang.String-----getName-----getName:reflect.User-----getoGenericString-----getoGenericString():private reflect.User(int,java.lang.String)*/- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
其中關(guān)于Type類型這里簡單說明一下，Type 是 Java 編程語言中所有類型的公共高級接口。它們包括原始類型、參數(shù)化類型、數(shù)組類型、類型變量和基本類型。getGenericParameterTypes?與?getParameterTypes?都是獲取構(gòu)成函數(shù)的參數(shù)類型，前者返回的是Type類型，后者返回的是Class類型，由于Type頂級接口，Class也實(shí)現(xiàn)了該接口，因此Class類是Type的子類，Type 表示的全部類型而每個(gè)Class對象表示一個(gè)具體類型的實(shí)例，如String.class僅代表String類型。由此看來Type與 Class 表示類型幾乎是相同的，只不過 Type表示的范圍比Class要廣得多而已。當(dāng)然Type還有其他子類，如：
TypeVariable：表示類型參數(shù)，可以有上界，比如：T extends Number
ParameterizedType：表示參數(shù)化的類型，有原始類型和具體的類型參數(shù)，比如：List<String>
WildcardType：表示通配符類型，比如：?, ? extends Number, ? super Integer
通過以上的分析，對于Constructor類已有比較清晰的理解，利用好Class類和Constructor類，我們可以在運(yùn)行時(shí)動態(tài)創(chuàng)建任意對象，從而突破必須在編譯期知道確切類型的障礙。
Field類及其用法
Field 提供有關(guān)類或接口的單個(gè)字段的信息，以及對它的動態(tài)訪問權(quán)限。反射的字段可能是一個(gè)類（靜態(tài)）字段或?qū)嵗侄巍Ｍ瑯拥牡览?#xff0c;我們可以通過Class類的提供的方法來獲取代表字段信息的Field對象，Class類與Field對象相關(guān)方法如下：
| Field | getDeclaredField(String name) | 獲取指定name名稱的(包含private修飾的)字段，不包括繼承的字段 |
| Field[] | getDeclaredField() | 獲取Class對象所表示的類或接口的所有(包含private修飾的)字段,不包括繼承的字段 |
| Field | getField(String name) | 獲取指定name名稱、具有public修飾的字段，包含繼承字段 |
| Field[] | getField() | 獲取修飾符為public的字段，包含繼承字段 |
??
下面的代碼演示了上述方法的使用過程
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
上述方法需要注意的是，如果我們不期望獲取其父類的字段，則需使用Class類的getDeclaredField/getDeclaredFields方法來獲取字段即可，倘若需要連帶獲取到父類的字段，那么請使用Class類的getField/getFields，但是也只能獲取到public修飾的的字段，無法獲取父類的私有字段。下面將通過Field類本身的方法對指定類屬性賦值，代碼演示如下：
//獲取Class對象引用 Class<?> clazz = Class.forName("reflect.Student");Student st= (Student) clazz.newInstance(); //獲取父類public字段并賦值 Field ageField = clazz.getField("age"); ageField.set(st,18); Field nameField = clazz.getField("name"); nameField.set(st,"Lily");//只獲取當(dāng)前類的字段,不獲取父類的字段 Field descField = clazz.getDeclaredField("desc"); descField.set(st,"I am student"); Field scoreField = clazz.getDeclaredField("score"); //設(shè)置可訪問，score是private的 scoreField.setAccessible(true); scoreField.set(st,88); System.out.println(st.toString());//輸出結(jié)果：Student{age=18, name='Lily ,desc='I am student', score=88} //獲取字段值 System.out.println(scoreField.get(st)); // 88- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
其中的set(Object obj, Object value)方法是Field類本身的方法，用于設(shè)置字段的值，而get(Object obj)則是獲取字段的值，當(dāng)然關(guān)于Field類還有其他常用的方法如下：
| void | set(Object obj, Object value) | 將指定對象變量上此 Field 對象表示的字段設(shè)置為指定的新值。 |
| Object | get(Object obj) | 返回指定對象上此 Field 表示的字段的值 |
| Class<?> | getType() | 返回一個(gè) Class 對象，它標(biāo)識了此Field 對象所表示字段的聲明類型。 |
| boolean | isEnumConstant() | 如果此字段表示枚舉類型的元素則返回 true；否則返回 false |
| String | toGenericString() | 返回一個(gè)描述此 Field（包括其一般類型）的字符串 |
| String | getName() | 返回此 Field 對象表示的字段的名稱 |
| Class<?> | getDeclaringClass() | 返回表示類或接口的 Class 對象，該類或接口聲明由此 Field 對象表示的字段 |
| void | setAccessible(boolean flag) | 將此對象的 accessible 標(biāo)志設(shè)置為指示的布爾值,即設(shè)置其可訪問性 |
??
上述方法可能是較為常用的，事實(shí)上在設(shè)置值的方法上，Field類還提供了專門針對基本數(shù)據(jù)類型的方法，如setInt()/getInt()、setBoolean()/getBoolean、setChar()/getChar()等等方法，這里就不全部列出了，需要時(shí)查API文檔即可。需要特別注意的是被final關(guān)鍵字修飾的Field字段是安全的，在運(yùn)行時(shí)可以接收任何修改，但最終其實(shí)際值是不會發(fā)生改變的。
Method類及其用法
Method 提供關(guān)于類或接口上單獨(dú)某個(gè)方法（以及如何訪問該方法）的信息，所反映的方法可能是類方法或?qū)嵗椒?#xff08;包括抽象方法）。下面是Class類獲取Method對象相關(guān)的方法：
| Method | getDeclaredMethod(String name, Class<?>... parameterTypes) | 返回一個(gè)指定參數(shù)的Method對象，該對象反映此 Class 對象所表示的類或接口的指定已聲明方法。 |
| Method[] | getDeclaredMethod() | 返回 Method 對象的一個(gè)數(shù)組，這些對象反映此 Class 對象表示的類或接口聲明的所有方法，包括公共、保護(hù)、默認(rèn)（包）訪問和私有方法，但不包括繼承的方法。 |
| Method | getMethod(String name, Class<?>... parameterTypes) | 返回一個(gè) Method 對象，它反映此 Class 對象所表示的類或接口的指定公共成員方法。 |
| Method[] | getMethods() | 返回一個(gè)包含某些 Method 對象的數(shù)組，這些對象反映此 Class 對象所表示的類或接口（包括那些由該類或接口聲明的以及從超類和超接口繼承的那些的類或接口）的公共 member 方法。 |
同樣通過案例演示上述方法：
import java.lang.reflect.Method;/*** Created by zejian on 2017/5/1.* Blog : http://blog.csdn.net/javazejian [原文地址,請尊重原創(chuàng)]*/ public class ReflectMethod {public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {Class clazz = Class.forName("reflect.Circle");//根據(jù)參數(shù)獲取public的Method,包含繼承自父類的方法Method method = clazz.getMethod("draw",int.class,String.class);System.out.println("method:"+method);//獲取所有public的方法:Method[] methods =clazz.getMethods();for (Method m:methods){System.out.println("m::"+m);}System.out.println("=========================================");//獲取當(dāng)前類的方法包含private,該方法無法獲取繼承自父類的methodMethod method1 = clazz.getDeclaredMethod("drawCircle");System.out.println("method1::"+method1);//獲取當(dāng)前類的所有方法包含private,該方法無法獲取繼承自父類的methodMethod[] methods1=clazz.getDeclaredMethods();for (Method m:methods1){System.out.println("m1::"+m);}}/**輸出結(jié)果:method:public void reflect.Shape.draw(int,java.lang.String)m::public int reflect.Circle.getAllCount()m::public void reflect.Shape.draw()m::public void reflect.Shape.draw(int,java.lang.String)m::public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedExceptionm::public final native void java.lang.Object.wait(long) throws java.lang.InterruptedExceptionm::public final void java.lang.Object.wait() throws java.lang.InterruptedExceptionm::public boolean java.lang.Object.equals(java.lang.Object)m::public java.lang.String java.lang.Object.toString()m::public native int java.lang.Object.hashCode()m::public final native java.lang.Class java.lang.Object.getClass()m::public final native void java.lang.Object.notify()m::public final native void java.lang.Object.notifyAll()=========================================method1::private void reflect.Circle.drawCircle()m1::public int reflect.Circle.getAllCount()m1::private void reflect.Circle.drawCircle()*/ }class Shape {public void draw(){System.out.println("draw");}public void draw(int count , String name){System.out.println("draw "+ name +",count="+count);}} class Circle extends Shape{private void drawCircle(){System.out.println("drawCircle");}public int getAllCount(){return 100;} }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
在通過getMethods方法獲取Method對象時(shí)，會把父類的方法也獲取到，如上的輸出結(jié)果，把Object類的方法都打印出來了。而getDeclaredMethod/getDeclaredMethods方法都只能獲取當(dāng)前類的方法。我們在使用時(shí)根據(jù)情況選擇即可。下面將演示通過Method對象調(diào)用指定類的方法：
Class clazz = Class.forName("reflect.Circle"); //創(chuàng)建對象 Circle circle = (Circle) clazz.newInstance();//獲取指定參數(shù)的方法對象Method Method method = clazz.getMethod("draw",int.class,String.class);//通過Method對象的invoke(Object obj,Object... args)方法調(diào)用 method.invoke(circle,15,"圈圈");//對私有無參方法的操作 Method method1 = clazz.getDeclaredMethod("drawCircle"); //修改私有方法的訪問標(biāo)識 method1.setAccessible(true); method1.invoke(circle);//對有返回值得方法操作 Method method2 =clazz.getDeclaredMethod("getAllCount"); Integer count = (Integer) method2.invoke(circle); System.out.println("count:"+count);/**輸出結(jié)果:draw 圈圈,count=15drawCirclecount:100 */- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
在上述代碼中調(diào)用方法，使用了Method類的invoke(Object obj,Object... args)第一個(gè)參數(shù)代表調(diào)用的對象，第二個(gè)參數(shù)傳遞的調(diào)用方法的參數(shù)。這樣就完成了類方法的動態(tài)調(diào)用。
| Object | invoke(Object obj, Object... args) | 對帶有指定參數(shù)的指定對象調(diào)用由此 Method 對象表示的底層方法。 |
| Class<?> | getReturnType() | 返回一個(gè) Class 對象，該對象描述了此 Method 對象所表示的方法的正式返回類型,即方法的返回類型 |
| Type | getGenericReturnType() | 返回表示由此 Method 對象所表示方法的正式返回類型的 Type 對象，也是方法的返回類型。 |
| Class<?>[] | getParameterTypes() | 按照聲明順序返回 Class 對象的數(shù)組，這些對象描述了此 Method 對象所表示的方法的形參類型。即返回方法的參數(shù)類型組成的數(shù)組 |
| Type[] | getGenericParameterTypes() | 按照聲明順序返回 Type 對象的數(shù)組，這些對象描述了此 Method 對象所表示的方法的形參類型的，也是返回方法的參數(shù)類型 |
| String | getName() | 以 String 形式返回此 Method 對象表示的方法名稱，即返回方法的名稱 |
| boolean | isVarArgs() | 判斷方法是否帶可變參數(shù)，如果將此方法聲明為帶有可變數(shù)量的參數(shù)，則返回 true；否則，返回 false。 |
| String | toGenericString() | 返回描述此 Method 的字符串，包括類型參數(shù)。 |
??
getReturnType方法/getGenericReturnType方法都是獲取Method對象表示的方法的返回類型，只不過前者返回的Class類型后者返回的Type(前面已分析過)，Type就是一個(gè)接口而已，在Java8中新增一個(gè)默認(rèn)的方法實(shí)現(xiàn)，返回的就參數(shù)類型信息
- 1
- 2
- 3
- 4
- 5
- 6
而getParameterTypes/getGenericParameterTypes也是同樣的道理，都是獲取Method對象所表示的方法的參數(shù)類型，其他方法與前面的Field和Constructor是類似的。
反射包中的Array類
在Java的java.lang.reflect包中存在著一個(gè)可以動態(tài)操作數(shù)組的類，Array，它提供了動態(tài)創(chuàng)建和訪問 Java 數(shù)組的方法。Array 允許在執(zhí)行 get 或 set 操作進(jìn)行取值和賦值。在Class類中與數(shù)組關(guān)聯(lián)的方法是：
| Class<?> | getComponentType() | 返回表示數(shù)組元素類型的 Class，即數(shù)組的類型 |
| boolean | isArray() | 判定此 Class 對象是否表示一個(gè)數(shù)組類。 |
java.lang.reflect.Array中的常用靜態(tài)方法如下：
| static Object | set(Object array, int index) | 返回指定數(shù)組對象中索引組件的值。 |
| static int | getLength(Object array) | 以 int 形式返回指定數(shù)組對象的長度 |
| static object | newInstance(Class<?> componentType, int... dimensions) | 創(chuàng)建一個(gè)具有指定類型和維度的新數(shù)組。 |
| static Object | newInstance(Class<?> componentType, int length) | 創(chuàng)建一個(gè)具有指定的組件類型和長度的新數(shù)組。 |
| static void | set(Object array, int index, Object value) | 將指定數(shù)組對象中索引組件的值設(shè)置為指定的新值。 |
下面通過一個(gè)簡單例子來演示這些方法
package reflect;import java.lang.reflect.Array;/*** Created by zejian on 2017/5/1.* Blog : http://blog.csdn.net/javazejian [原文地址,請尊重原創(chuàng)]*/ public class ReflectArray {public static void main(String[] args) throws ClassNotFoundException {int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };//獲取數(shù)組類型的Class 即int.classClass<?> clazz = array.getClass().getComponentType();//創(chuàng)建一個(gè)具有指定的組件類型和長度的新數(shù)組。//第一個(gè)參數(shù):數(shù)組的類型,第二個(gè)參數(shù):數(shù)組的長度Object newArr = Array.newInstance(clazz, 15);//獲取原數(shù)組的長度int co = Array.getLength(array);//賦值原數(shù)組到新數(shù)組System.arraycopy(array, 0, newArr, 0, co);for (int i:(int[]) newArr) {System.out.print(i+",");}//創(chuàng)建了一個(gè)長度為10 的字符串?dāng)?shù)組，//接著把索引位置為6 的元素設(shè)為"hello world!"，然后再讀取索引位置為6 的元素的值Class clazz2 = Class.forName("java.lang.String");//創(chuàng)建一個(gè)長度為10的字符串?dāng)?shù)組，在Java中數(shù)組也可以作為Object對象Object array2 = Array.newInstance(clazz2, 10);//把字符串?dāng)?shù)組對象的索引位置為6的元素設(shè)置為"hello"Array.set(array2, 6, "hello world!");//獲得字符串?dāng)?shù)組對象的索引位置為5的元素的值String str = (String)Array.get(array2, 6);System.out.println();System.out.println(str);//hello}/**輸出結(jié)果:1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,hello world!*/ }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
通過上述代碼演示，確實(shí)可以利用Array類和反射相結(jié)合動態(tài)創(chuàng)建數(shù)組，也可以在運(yùn)行時(shí)動態(tài)獲取和設(shè)置數(shù)組中元素的值，其實(shí)除了上的set/get外Array還專門為8種基本數(shù)據(jù)類型提供特有的方法，如setInt/getInt、setBoolean/getBoolean，其他依次類推，需要使用是可以查看API文檔即可。除了上述動態(tài)修改數(shù)組長度或者動態(tài)創(chuàng)建數(shù)組或動態(tài)獲取值或設(shè)置值外，可以利用泛型動態(tài)創(chuàng)建泛型數(shù)組如下：
/*** 接收一個(gè)泛型數(shù)組，然后創(chuàng)建一個(gè)長度與接收的數(shù)組長度一樣的泛型數(shù)組，* 并把接收的數(shù)組的元素復(fù)制到新創(chuàng)建的數(shù)組中，* 最后找出新數(shù)組中的最小元素，并打印出來* @param a* @param <T>*/public <T extends Comparable<T>> void min(T[] a) {//通過反射創(chuàng)建相同類型的數(shù)組T[] b = (T[]) Array.newInstance(a.getClass().getComponentType(), a.length);for (int i = 0; i < a.length; i++) {b[i] = a[i];}T min = null;boolean flag = true;for (int i = 0; i < b.length; i++) {if (flag) {min = b[i];flag = false;}if (b[i].compareTo(min) < 0) {min = b[i];}}System.out.println(min);}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
畢竟我們無法直接創(chuàng)建泛型數(shù)組，有了Array的動態(tài)創(chuàng)建數(shù)組的方式這個(gè)問題也就迎刃而解了。
//無效語句，編譯不通 T[] a = new T[];- 1
- 2
ok~，到這反射中幾個(gè)重要并且常用的類我們都基本介紹完了，但更重要是，我們應(yīng)該認(rèn)識到反射機(jī)制并沒有什么神奇之處。當(dāng)通過反射與一個(gè)未知類型的對象打交道時(shí)，JVM只會簡單地檢查這個(gè)對象，判斷該對象屬于那種類型，同時(shí)也應(yīng)該知道，在使用反射機(jī)制創(chuàng)建對象前，必須確保已加載了這個(gè)類的Class對象，當(dāng)然這點(diǎn)完全不必由我們操作，畢竟只能JVM加載，但必須確保該類的”.class”文件已存在并且JVM能夠正確找到。關(guān)于Class類的方法在前面我們只是分析了主要的一些方法，其實(shí)Class類的API方法挺多的，建議查看一下API文檔，瀏覽一遍，有個(gè)印象也是不錯(cuò)的選擇，這里僅列出前面沒有介紹過又可能用到的API：
/** * 修飾符、父類、實(shí)現(xiàn)的接口、注解相關(guān) *///獲取修飾符，返回值可通過Modifier類進(jìn)行解讀 public native int getModifiers(); //獲取父類，如果為Object，父類為null public native Class<? super T> getSuperclass(); //對于類，為自己聲明實(shí)現(xiàn)的所有接口，對于接口，為直接擴(kuò)展的接口，不包括通過父類間接繼承來的 public native Class<?>[] getInterfaces(); //自己聲明的注解 public Annotation[] getDeclaredAnnotations(); //所有的注解，包括繼承得到的 public Annotation[] getAnnotations(); //獲取或檢查指定類型的注解，包括繼承得到的 public <A extends Annotation> A getAnnotation(Class<A> annotationClass); public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass);/** * 內(nèi)部類相關(guān)*/ //獲取所有的public的內(nèi)部類和接口，包括從父類繼承得到的 public Class<?>[] getClasses(); //獲取自己聲明的所有的內(nèi)部類和接口 public Class<?>[] getDeclaredClasses(); //如果當(dāng)前Class為內(nèi)部類，獲取聲明該類的最外部的Class對象 public Class<?> getDeclaringClass(); //如果當(dāng)前Class為內(nèi)部類，獲取直接包含該類的類 public Class<?> getEnclosingClass(); //如果當(dāng)前Class為本地類或匿名內(nèi)部類，返回包含它的方法 public Method getEnclosingMethod();/** * Class對象類型判斷相關(guān)*/ //是否是數(shù)組 public native boolean isArray(); //是否是基本類型 public native boolean isPrimitive(); //是否是接口 public native boolean isInterface(); //是否是枚舉 public boolean isEnum(); //是否是注解 public boolean isAnnotation(); //是否是匿名內(nèi)部類 public boolean isAnonymousClass(); //是否是成員類 public boolean isMemberClass(); //是否是本地類 public boolean isLocalClass();- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
ok~，本篇到此完結(jié)。
from:?https://blog.csdn.net/javazejian/article/details/70768369
《新程序員》：云原生和全面數(shù)字化實(shí)踐50位技術(shù)專家共同創(chuàng)作，文字、視頻、音頻交互閱讀總結(jié)
以上是生活随笔為你收集整理的深入理解Java类型信息(Class对象)与反射机制的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： MySQL的进阶实战篇
- 下一篇： 浅谈java枚举类