java反射-使用反射獲取類的所有信息

在OOP(面向對象)語言中，最重要的一個概念就是：萬事萬物皆對象。

在java中，類也是一個對象，是java.lang.Class的實例對象，官網稱該對象為類的類類型。

Class 類的實例表示正在運行的 Java 應用程式中的類和介面。基本的 Java 類型（boolean、byte、char、short、int、long、float 和 double）和關鍵字 void 也表示為 Class 對象。

Class 沒有公共構造方法。Class 對象是在載入類時由 Java 虛擬機以及通過調用類載入器中的 defineClass 方法自動構造的。

一個類的類類型有三種表示方式：

　　1.ClassName.class：類名.class，這種方式ying隱式的說明瞭任何一個類都有一個靜態成員變數class。

　　2.obj.getClass()：通過實例對象.getClass()來獲取該類的類類型。

　　3.Class.forName("xxx")：xxx表示類的全稱，該方式代表動態載入類。

既然有了動態載入類，辣麽肯定有靜態載入類，辣麽這兩種是什麼意思呢？

動態載入類：jvm運行時刻載入類。

靜態載入類：編譯時刻載入類，表示在編譯時刻就需要載入所有的可能使用到的類。

　　簡單舉個慄子：使用new創建一個對象，我們在運行程式的時候，該對象的類必須存在，否則會產生編譯錯誤，這種方式就是靜態載入類。如果使用了Object obj = Class.forName("xxx")來創建實例，只有在運行時候，該類不存在時，才會拋出異常，這種方式就是動態載入類。

　　使用動態載入類，可以根據優雅的設計我們的代碼，比如：

// 介面 A ，存在方法 print
// ClassB  實現了介面 A
// ClassC  實現了介面 A
// ClassD  實現了介面 A

// 通過動態載入，根據傳入的類全稱不同，創建不同的實例對象。調用方法 a，這執行對應實例的代碼塊
A a = Class.forName(classPakeage);
a.print();

下麵我使用代碼來獲取一個類的基本信息:

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * java反射 工具類
 */
public class ClassUtil {

    /**
     * 獲取 obj 對象的所有信息，並列印 obj 類
　　　* 該方法中，getXXXXs()方法都表示獲取此對象所有 public 類型
　　  * 對應的方法getDeclaredXXXs()方法表示獲取該對象實現的所有對象(萬事萬物皆對象),不論訪問許可權
     * @param obj
     */
    public static void getClassMsg(Object obj){
        // 1.獲取obj類的類類型
        Class c = obj.getClass();
        // 2.獲取類 pageage
        Package pa = c.getPackage();
        System.out.println(pa.getName());
        // 3.獲取類註釋
        Annotation[] annotations = c.getAnnotations();
        for (Annotation annotation : annotations){
            System.out.println(annotation.toString());
        }
        System.out.print(c.getName() + " ");
        // 4.獲取類的父類
        Class superClass = c.getSuperclass();
        if(superClass != null){
            System.out.print("extends " + superClass.getName());
        }
        // 5.獲取類實現的介面
        Class[] interfaces = c.getInterfaces();
        if(interfaces.length != 0){
            System.out.print(" implements ");
            Class iface;
            for (int i = 0,len = interfaces.length; i < len; i++){
                iface = interfaces[i];
                System.out.print(iface.getName());
            }
        }
        System.out.println(" {");
        // 6.獲取類的屬性
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields){
            System.out.println(field.getName() + ";");
        }
        // 7.獲取類的構造方法
        Constructor[] constructors = c.getDeclaredConstructors();
        for (Constructor constructor : constructors){
            System.out.print(constructor.getName() + "(");
            Class[] params = constructor.getParameterTypes();
            for (int i = 0,len = params.length; i < len; i++){
                System.out.print(params[i].getName());
                if(i != len - 1){
                    System.out.print(",");
                }
            }
            System.out.print(") {...}\n");
        }
        // 8.獲取類的方法
        Method[] methods = c.getDeclaredMethods();
        for (Method mt : methods){
            System.out.print(mt.getName() + "(");
            Class[] params = mt.getParameterTypes();
            for (int i = 0,len = params.length; i < len; i++){
                System.out.print(params[i].getName());
                if(i != len - 1){
                    System.out.print(",");
                }
            }
            System.out.print(") {...}\n");
        }
        System.out.println("}");
    }
}