Java深入分析講解反射機制
反射的概述
JAVA反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱為java語言的反射機制。要想解剖一個類,必須先要獲取到該類的字節碼文件對象。而解剖使用的就是Class類中的方法.所以先要獲取到每一個字節碼文件對應的Class類型的對象.
獲取Class對象的三種方式
第一種方式：
通過調用java.lang.Class類下的靜態方法：static Class forName(String className)
註意：
- 參數是一個帶有包名的完整類名(同目錄下的可以隻寫類名)。
- 拋出編譯時異常：
ClassNotFountException。 - 該方法會導致相應的類被類加載。
代碼如下：
public class MyClass {
static{
System.out.println("靜態代碼塊執行！");
}
}
class Test{
Class c = Class.forName("MyClass");
}
編譯結果：
第二種方式：
Object類下有個方法: public final Class getClass() —– 返回此對象的Class。
代碼如下：
Date d = new Date(); Class c2 = d.getClass();
第三種方式：
Java種任何一種類型，包括基本數據類型，都有class靜態屬性，直接通過 類名.class,就可以返回相應的Class類。
代碼如下：
Class c = Date.class;
通過反射機制獲取類的屬性
相關方法：
public Field[] getFields() ——- java.lang.Class中的方法，將類中public修飾的屬性以數組的形式返回
public Field[] getDeclaredFields() —— java.lang.Class中的方法，將類中所有的屬性以數組的形式返回
public Class getType() —— java.lang.reflect.Field中的方法，獲取屬性的類型並返回
public int getModifiers() —– java.lang.reflect.Field中的方法，獲取屬性的修飾符，並以整數編碼的形式返回(一個整數編碼可能代表多個修飾符)
static String toString(int mod) —— java.lang.reflect.Modifier中的靜態方法，傳入修飾符的整數編碼，以字符串的形式將修飾符返回
代碼如下：
public class ReflectTest05 {
public static void main(String[] args) throws Exception{
Class c = Class.forName("java.lang.String");
StringBuffer s = new StringBuffer();
s.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() + "{\n");
Field[] fields = c.getDeclaredFields();
for(Field f:fields){
s.append("\t" + Modifier.toString(f.getModifiers()) + " "+ f.getType().getName()+ " " +f.getName()+"\n");
}
s.append("}");
System.out.println(s);
}
}
編譯結果如下：
通過反射機制訪問Java對象的屬性
創建一個User類，如下：
public class User {
//四個Field對象，分別采用四種不同的訪問權限修飾符
public int no;
private String name;
protected int age;
boolean sex;
}
代碼如下：
public class ReflectTest06 {
public static void main(String[] args) throws Exception{
Class c = Class.forName("User");
//通過反射實例化User類
Object user = c.newInstance();
//設置User對象的no
Field field = c.getDeclaredField("no");
field.set(user,12);
//獲得User對象的no
System.out.println(field.get(user));
//設置User對象的name，需要打破封裝，因為name屬性是私有屬性，不能直接設置
Field field1 = c.getDeclaredField("name");
field1.setAccessible(true);
field1.set(user,"Joke");
System.out.println(field1.get(user));
}
}
反射機制與屬性配置文件的配合使用
資源綁定器
java.util包下提供瞭一個資源綁定器，便於獲取屬性配置文件中的內容。
使用以下這種方式的時候，屬性配置文件xxx.properties必須放到類路徑下。
代碼如下：
public class ResourceBundleTest01 {
public static void main(String[] args) {
//資源綁定器，隻能綁定xxx.properties文件，並且這個文件必須在類路徑下，文件擴展名也必須是properties
//並且在寫路徑時，路徑後面的擴展名不能寫
ResourceBundle bundle = ResourceBundle.getBundle("classinfo");
String className = bundle.getString("className");
System.out.println(className);
}
}
配合使用樣例
首先我們創建一個屬性配置文件，如下：
className = User
fieldName = name
fieldValue = zhangsan
樣例代碼如下：
public class ReflectTest07 {
public static void main(String[] args) throws Exception{
//配合屬性文件使用
ResourceBundle bundle = ResourceBundle.getBundle("classinfo");
Class c2 = Class.forName(bundle.getString("className"));
//通過反射實例化User類
Object obj = c2.newInstance();
Field field1 = c2.getDeclaredField(bundle.getString("fieldName"));
//打破封裝
field1.setAccessible(true);
field1.set(obj,bundle.getString("fieldValue"));
System.out.println(field1.get(obj));
}
}
通過反射機制獲取類中方法
代碼如下：
public class ReflectTest08 {
public static void main(String[] args)throws Exception {
Class c = Class.forName("java.lang.String");
Method[] methods = c.getDeclaredMethods();
StringBuffer s = new StringBuffer();
for(Method m:methods){
Class[] parameterTypes = m.getParameterTypes();
s.append(Modifier.toString(m.getModifiers()) + " " + m.getReturnType().getSimpleName() + " " + m.getName() + "(");
for(Class cs:parameterTypes){
s.append(cs.getSimpleName() + " ");
}
s.append("){}\n");
}
System.out.println(s);
}
}
編譯結果：
通過反射機制調用Java對象的方法
使用反射機制調用一個對象的方法,步驟如下：
- 獲取對應類的Class對象。
- 通過反射機制實例化出一個對象。
- 通過方法 ：
public Method getDeclaredMethod(String name, Class... parameterTypes)，獲取對應的Method對象
註意：getDeclaredMethod方法是在java.lang.Class下的方法，第一個參數是方法名，第二個參數是可變長參數，是該方法的形式參數類型列表
- 通過方法：
public Object invoke(Object obj,Object... args)，可以調用Method對象對應的方法。
註意：該方法是java.lang.reflect.Method下的方法，第一個參數是對象，第二個參數是方法的實際參數列表。
往User類中添加方法，如下：
public class User {
//四個Field對象，分別采用四種不同的訪問權限修飾符
public int no;
private String name;
protected int age;
boolean sex;
public int doSome(int i){
System.out.println("User對象中的doSome方法執行！");
return i;
}
}
代碼如下：
public class ReflectTest09 {
public static void main(String[] args)throws Exception {
Class c = Class.forName("User");
Object obj = c.newInstance();
Method method = c.getDeclaredMethod("doSome",int.class);
System.out.println(method.invoke(obj,1));
}
}
編譯結果如下：
通過反射機制獲取類中的構造方法
public class ReflectTest10 {
public static void main(String[] args)throws Exception {
Class c = Class.forName("java.lang.String");
Constructor[] constructors = c.getDeclaredConstructors();
StringBuffer s = new StringBuffer();
for(Constructor co: constructors){
s.append(Modifier.toString(co.getModifiers()) + " " +c.getSimpleName() + "(");
Class[] parameterType = co.getParameterTypes();
for(Class cs:parameterType){
s.append(cs.getSimpleName()+" ");
}
s.append("){}\n");
}
System.out.println(s);
}
}
編譯結果如下：
通過反射機制創建對象(調用構造方法)
代碼如下：
public class ReflectTest11 {
public static void main(String[] args)throws Exception {
Class c = Class.forName("User");
//默認調用無參數構造方法
Object obj1 = c.newInstance();
//因為每一個構造方法的方法名都一樣，所以getDeclaredConstructor方法的參數隻有要調用的構造方法的構造參數類型列表
Constructor constructor = c.getDeclaredConstructor(int.class,String.class,int.class,boolean.class);
Object obj2 = constructor.newInstance(1111,"zhangsan",18,true);
System.out.println(obj2);
}
}
通過反射機制獲取一個類的父類和父接口
代碼如下：
public class ReflectTest12 {
public static void main(String[] args)throws Exception {
Class c = Class.forName("java.lang.String");
//一個類最多隻有一個父類
Class superClass = c.getSuperclass();
System.out.println(superClass.getName());
//一個類可以實現多個接口
Class[] superInterfaces = c.getInterfaces();
for(Class i: superInterfaces){
System.out.println(i.getName());
}
}
}
編譯結果如下：
到此這篇關於Java深入分析講解反射機制的文章就介紹到這瞭,更多相關Java反射機制內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！