Java泛型機制與反射原理相關(guān)知識總結(jié)

更新時間：2021年06月23日 08:37:03 作者：知了一笑

今天帶大家學習的是關(guān)于Java進階的相關(guān)知識,文章圍繞著Java泛型機制與反射原理展開,文中有非常詳細的介紹及代碼示例,需要的朋友可以參考下

一、泛型的概念

1.1 基礎(chǔ)案例

泛型在Java中的應(yīng)用非常廣泛，最常見則是在集合容器中，先看下基礎(chǔ)用法：

public class Generic01 {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>() ;
        map.put(88,"hello") ;
        // map.put("99","world") ; 輸入編譯錯誤
        String value = map.get(88) ;
        // Integer value = map.get(88) ; 輸出編譯錯誤
        System.out.println("value:"+value);
    }
}

聲明一個map類型的容器，并且明確限定key和value的類型：分別為Integer,String，這樣顯然不能體現(xiàn)特別之處，可以對比下面的用法：

Map newMap = new HashMap() ;
newMap.put("hello","world");
newMap.put(88,99);

在不指定類型的情況下，鍵值對都默認為Object類型，這樣的容器在使用的時候要時刻注意不同的key類型和取出的value值類型，并且value要做類型轉(zhuǎn)換，相比之下泛型機制就很有必要。

可以看下Map接口的定義：

public interface Map<K,V> {
    V get(Object key);
    V put(K key, V value);
}

在Map接口中，<K,V>顯然沒有指定明確的類型，只是起到類型傳遞的作用，即K是key的類型，V是value的類型，在上面的源碼中描述的很清楚，結(jié)合上面案例，在Map對象聲明的時候可以明確指定<K,V>的類型，也可以缺省為Object類型。

1.2 泛型描述

泛型即可以理解為把數(shù)據(jù)類型作為參數(shù)，即參數(shù)化類型，用來提高代碼的安全性，靈活性，避免類型轉(zhuǎn)換；代碼簡潔明了，同時對于程序的可擴展性起到至關(guān)重要的作用。

首先設(shè)計一個簡單的頂層接口，只定義一個callBack方法，和對出入?yún)?shù)的簡單邏輯設(shè)定，這種設(shè)計在Java的源碼設(shè)計中隨處可見，例如上面的集合體系：

/**
 * 基礎(chǔ)接口設(shè)計
 * @param <R> 返參類型
 * @param <V> 入?yún)㈩愋?
 */
interface CallBack<R,V> {
    /**
     * 回調(diào)方法：V 方法入?yún)?，R 方法返回值
     */
    R callBack (V v) ;
}

為了實現(xiàn)具體的業(yè)務(wù)，再基于頂層接口向下做擴展，這里聲明兩個擴展接口，作為具體業(yè)務(wù)類的接口：

/**
 * 擴展接口設(shè)計01
 */
interface ExtCallBack01<R extends Integer,V extends List<String>>
                        extends CallBack<Integer,List<String>> {
    @Override
    Integer callBack (List<String> list) ;
}
/**
 * 擴展接口設(shè)計01
 */
interface ExtCallBack02<R extends Boolean,V extends Map<String,Long>>
        extends CallBack<Boolean,Map<String,Long>> {
    @Override
    Boolean callBack (Map<String,Long> map) ;
}

這樣可以通過擴展接口去設(shè)計具體的業(yè)務(wù)類，提高程序的靈活可擴展性：

public class Generic02 {
    public static void main(String[] args) {
        new ExtCallBack01<Integer,List<String>>(){
            @Override
            public Integer callBack(List<String> list) {
                list.add("hello");
                return list.size();
            }
        };
        new ExtCallBack02<Boolean,Map<String,Long>> (){
            @Override
            public Boolean callBack(Map<String, Long> map) {
                map.put("Fire",119L) ;
                return map.size()>0 ;
            }
        } ;
    }
}

通過上面這個案例，可以清楚的感覺到泛型機制的靈活和強大。

1.3 泛型本質(zhì)

泛型雖然可以使用在類，接口，方法，參數(shù)等各個地方，但是其約束能力是在代碼的編譯期：

public class Generic03 {
    public static void main(String[] args) {
        DefEntry<String> defEntry1 = new DefEntry<>("hello") ;
        DefEntry<Long> defEntry2 = new DefEntry<>(999L) ;
        // Always True
        System.out.println(defEntry1.getClass()==defEntry2.getClass());
    }
}
class DefEntry<T> {
    private T param ;
    public DefEntry (T param){
        this.param = param ;
    }
}

編譯過程中，會對泛型合法性作校驗，校驗成功編譯的class文件沒有泛型信息，即泛型擦除掉，通過一個簡單的命令查看編譯后的文件：

javap -v Generic03.class

當然這也會帶來安全問題：

public static void main(String[] args) throws Exception {
    Map<String, String> map = new HashMap<>();
    Method method = HashMap.class.getDeclaredMethod("put",
                                new Class[] { Object.class, Object.class });
    method.invoke(map,888L, 999L);
    // {888=999}
    System.out.println(map);
    // java.lang.ClassCastException
    System.out.println(map.get(888L));
}

這里即通過反射的機制，繞開泛型，在map中放入程序語義上的非法值類型，在運行過程中獲取值的時候才拋出類型轉(zhuǎn)換異常。

二、反射機制

2.1 基礎(chǔ)描述

反射機制可以在程序運行時獲取類的完整結(jié)構(gòu)信息，并且可以動態(tài)的操作屬性和方法等。

對于反射機制的理解，必須要對類編譯和JVM加載，運行時數(shù)據(jù)區(qū)有清楚的認識，這塊內(nèi)容可以移步JVM系列的文章。

通過運行時動態(tài)獲取類的結(jié)構(gòu)，然后動態(tài)的創(chuàng)建對象并操作屬性和方法，這種方式在實際開發(fā)中并不多用，這樣很明顯會消耗JVM資源，并且會忽略一些封裝導(dǎo)致安全問題，這在上面【1】中已經(jīng)案例說明了。

2.2 反射的類庫

java.lang.Class：Class類
java.lang.reflect.Constructor：構(gòu)造器
java.lang.reflect.Field：屬性
java.lang.reflect.Method：方法

API之Class對象

獲取目標類型的Class對象常見方式，通過Class對象再獲取相關(guān)結(jié)構(gòu)信息，從而操作或者訪問：

public static void main(String[] args) throws Exception {
    // Class對象回去
    User user1 = new User(1,"name01") ;
    Class userClass1 = user1.getClass() ;
    Class userClass2 = Class.forName("com.java.reflect.User");
    Class userClass3 = User.class ;
    System.out.println(User.class.getName());
    System.out.println("userClass1==userClass2?"+(userClass1==userClass2));
    System.out.println("userClass2==userClass3?"+(userClass2==userClass3));
    // 類型創(chuàng)建和判斷
    Object object = User.class.newInstance() ;
    System.out.println("類型："+(object instanceof User));
    System.out.println("類型："+(userClass3.isInstance(user1)));
}

輸出結(jié)果：

這里有個注意點：通過Class對象的newInstance()方法，即基于User類的無參構(gòu)造器，首先要求User類具有無參構(gòu)造方法。

API之Constructor構(gòu)造器

Class對象讀取構(gòu)造方法，可以分別獲得全部構(gòu)造方法，不同修飾類型的構(gòu)造方法，或者根據(jù)構(gòu)造參數(shù)類型指定獲?。?/p>

public static void main(String[] args) throws Exception {
    Class userClass = User.class ;
    
    // 讀取公共構(gòu)造方法
    Constructor[] userConArr = userClass.getConstructors();
    printCon(userConArr);
    
    // 讀取指定私有構(gòu)造方法
    Constructor privateCon = userClass.getDeclaredConstructor(Integer.class);
    System.out.println(privateCon);
    
    // 讀取全部構(gòu)造方法
    userConArr = userClass.getDeclaredConstructors();
    printCon(userConArr);
    
    // 調(diào)用公共構(gòu)造方法創(chuàng)建對象
    Constructor pubCon = userClass.getConstructor(Integer.class,String.class);
    Object pubUser = pubCon.newInstance(1,"hello") ;
    
    // 調(diào)用私有構(gòu)造方法創(chuàng)建對象
    Constructor priCon = userClass.getDeclaredConstructor(Integer.class);
    // 忽略private權(quán)限修飾符
    priCon.setAccessible(Boolean.TRUE);
    Object priUser = priCon.newInstance(2) ;
    System.out.println(pubUser+"\n"+priUser);
}
public static void printCon (Constructor[] constructors){
    for (Constructor constructor:constructors){
        System.out.println(constructor);
    }
}

這里需要注意的是，通過調(diào)用setAccessible(Boolean.TRUE)方法，可以基于私有構(gòu)造方法創(chuàng)建對象，這里明顯違背了Java的基本設(shè)計原則，破壞代碼的安全性。

API之Field屬性

Field保證成員變量的屬性，修飾符，值管理等相關(guān)操作：

public static void main(String[] args) throws Exception {
    Class userClass = User.class ;
    // 獲取公共字段
    Field[] pubArr = userClass.getFields() ;
    printField(pubArr);
    
    // 獲取全部字段
    Field[] fieldArr = userClass.getDeclaredFields() ;
    printField(fieldArr);
    
    // 獲取指定字段
    Field emailField = userClass.getField("email") ;
    Field nameField = userClass.getDeclaredField("name") ;
    printField(new Field[]{emailField,nameField});
    
    // 創(chuàng)建對象并操作屬性
    Object userObj = userClass.newInstance() ;
    nameField.setAccessible(Boolean.TRUE);
    nameField.set(userObj,"world");
    emailField.set(userObj,"test@email.com");
    System.out.println("userObj:"+userObj);
}
/**
 * 打印成員變量信息
 */
public static void printField (Field[] fields){
    for (Field field : fields){
        System.out.println("聲明："+field);
        UserAnno userAnno = field.getAnnotation(UserAnno.class) ;
        System.out.println("注解："+userAnno.desc());
        String fieldName = field.getName() ;
        System.out.println("名稱："+fieldName);
        Type type = field.getGenericType() ;
        System.out.println("類型："+type);
    }
}

注意這里獲取Type類型信息，在有些特定的業(yè)務(wù)場景下還是十分有用的。

API之Method方法

public static void main(String[] args) throws Exception {
    Class userClass = User.class ;
    // 獲取所有公共方法[包括父類和Object類方法]
    Method[] pubMethods = userClass.getMethods() ;
    printMethod(pubMethods);
    // 獲取全部方法
    Method[] allMethods = userClass.getDeclaredMethods() ;
    printMethod(allMethods);
    // 獲取指定方法
    Method method = userClass.getMethod("parName",String.class) ;
    printMethod(new Method[]{method});
    // 調(diào)用方法
    Object userObj = userClass.newInstance() ;
    Method setId = userClass.getDeclaredMethod("setId", Integer.class);
    setId.invoke(userObj,99) ;
    Method setName = userClass.getDeclaredMethod("setName", String.class);
    setName.invoke(userObj,"java") ;
    Method sayHi = userClass.getDeclaredMethod("sayHi", String.class);
    sayHi.setAccessible(Boolean.TRUE);
    sayHi.invoke(userObj,"c++");
    System.out.println(userObj);
}
/**
 * 打印方法信息
 */
public static void printMethod (Method[] methods){
    for (Method method : methods){
        System.out.println("定義："+method);
        System.out.println("命名："+method.getName());
        UserAnno userAnno = method.getAnnotation(UserAnno.class) ;
        if (userAnno != null){
            System.out.println("注解："+userAnno.desc());
        }
        Type[] paramTypeArr = method.getParameterTypes();
        for (int i=0 ; i< paramTypeArr.length; i++){
            System.out.print("參數(shù)"+(i+1)+"類型："+paramTypeArr[i]+" ; ");
        }
        System.out.println("參數(shù)個數(shù)："+method.getParameterCount());
    }
}

注意這里對方法的獲取遠遠不止類本身定義的，包括從父類繼承的，和Java基礎(chǔ)Object類中的。