詳解Java泛型type體系整理

作者：agapple 2011-03-21 16:26:28

一直對jdk的ref使用比較模糊，早上花了點時間簡單的整理了下，也幫助自己理解一下泛型的一些處理。

java中class,method,field的繼承體系

java中所有對象的類型定義類Type

說明：

Type : Type is the common superinterface for all types in the Java programming language. These include raw types, parameterized types, array types, type variables and primitive types.

使用

一般我們不直接操作Type類型，所以第一次使用會對這個比較陌生，相對內部的一些概念。

根據Type類型分類，整理了一個type -> class的轉換過程，同理也包括處理Generic Type。支持多級泛型處理。

Java代碼

private static Class getClass(Type type, int i) {     
        if (type instanceof ParameterizedType) { // 處理泛型類型     
            return getGenericClass((ParameterizedType) type, i);     
        } else if (type instanceof TypeVariable) {     
            return (Class) getClass(((TypeVariable) type).getBounds()[0], 0); // 處理泛型擦拭對象     
        } else {// class本身也是type，強制轉型     
            return (Class) type;     
        }     
    }     
    
    private static Class getGenericClass(ParameterizedType parameterizedType, int i) {     
        Object genericClass = parameterizedType.getActualTypeArguments()[i];     
        if (genericClass instanceof ParameterizedType) { // 處理多級泛型     
            return (Class) ((ParameterizedType) genericClass).getRawType();     
        } else if (genericClass instanceof GenericArrayType) { // 處理數組泛型     
            return (Class) ((GenericArrayType) genericClass).getGenericComponentType();     
        } else if (genericClass instanceof TypeVariable) { // 處理泛型擦拭對象     
            return (Class) getClass(((TypeVariable) genericClass).getBounds()[0], 0);     
        } else {     
            return (Class) genericClass;     
        }     
    }

測試代碼：

Java代碼

interface GeneircInteface {     
    
    T method1(T obj);     
}     
    
interface CommonInteface {     
    
    Integer method2(Integer obj);     
}     
    
class BaseGeneircInteface implements GeneircInteface {     
    
    protected R result;     
    
    @Override    
    public R method1(R obj) {     
        return obj;     
    }     
    
}     
    
class GenericClass extends BaseGeneircInteface> implements GeneircInteface>, CommonInteface {     
    
    @Override    
    public List method1(List obj) {     
        result = obj;     
        return result;     
    }     
    
    public Integer method2(Integer obj) {     
        return obj;     
    }     
    
    public extends Throwable> T method3(T obj) throws E {     
        return obj;     
    }     
    
}

針對class的泛型接口使用：

Java代碼

private static void classGeneric() {     
        System.out.println("\n--------------------- classGeneric ---------------------");     
        GenericClass gc = new GenericClass();     
        Type[] gis = gc.getClass().getGenericInterfaces(); // 接口的泛型信息     
        Type gps = gc.getClass().getGenericSuperclass(); // 父類的泛型信息     
        TypeVariable[] gtr = gc.getClass().getTypeParameters(); // 當前接口的參數信息     
        System.out.println("============== getGenericInterfaces");     
        for (Type t : gis) {     
            System.out.println(t + " : " + getClass(t, 0));     
        }     
        System.out.println("============== getGenericSuperclass");     
        System.out.println(getClass(gps, 0));     
        System.out.println("============== getTypeParameters");     
        for (TypeVariable t : gtr) {     
            StringBuilder stb = new StringBuilder();     
            for (Type tp : t.getBounds()) {     
                stb.append(tp + " : ");     
            }     
    
            System.out.println(t + " : " + t.getName() + " : " + stb);     
        }     
    
    }

針對method的泛型接口使用：

Java代碼

private static void methodGeneric() throws Exception {     
        System.out.println("\n--------------------- methodGeneric ---------------------");     
        GenericClass gc = new GenericClass();     
        Method method3 = gc.getClass().getDeclaredMethod("method3", new Class[] { Object.class });     
    
        Type[] gpt3 = method3.getGenericParameterTypes();     
        Type[] get3 = method3.getGenericExceptionTypes();     
        Type gt3 = method3.getGenericReturnType();     
        System.out.println("============== getGenericParameterTypes");     
        for (Type t : gpt3) {     
            System.out.println(t + " : " + getClass(t, 0));     
        }     
        System.out.println("============== getGenericExceptionTypes");     
        for (Type t : get3) {     
            System.out.println(t + " : " + getClass(t, 0));     
        }     
        System.out.println("============== getType");     
        System.out.println(gt3 + " : " + getClass(gt3, 0));     
    }

針對field的泛型接口使用：

Java代碼

private static void fieldGeneric() throws Exception {     
        System.out.println("\n--------------------- fieldGeneric ---------------------");     
        GenericClass gc = new GenericClass();     
        Field field = gc.getClass().getSuperclass().getDeclaredField("result");     
    
        Type gt = field.getGenericType();     
        Type ft = field.getType();     
        System.out.println("============== getGenericType");     
        System.out.println(gt + " : " + getClass(gt, 0));     
        System.out.println("============== getType");     
        System.out.println(ft + " : " + getClass(ft, 0));     
    }

輸出結果：

Java代碼

--------------------- classGeneric ---------------------     
============== getGenericInterfaces     
com.agapple.misc.GeneircInteface> : interface java.util.List     
interface com.agapple.misc.CommonInteface : interface com.agapple.misc.CommonInteface     
============== getGenericSuperclass     
interface java.util.List     
============== getTypeParameters     
    
--------------------- fieldGeneric ---------------------     
============== getGenericType     
R : class java.lang.Object     
============== getType     
class java.lang.Object : class java.lang.Object     
    
--------------------- methodGeneric ---------------------     
============== getGenericParameterTypes     
T : class java.lang.Object     
============== getGenericExceptionTypes     
E : class java.lang.Throwable     
============== getType     
T : class java.lang.Object

結果說明：

因為泛型的擦拭，對應的GeneircInteface和BaseGeneircInteface，在源碼信息已被擦除對應的類型，進行了upper轉型，所以取到的是Object。可以使用extends

GenericClass在類定義時，聲明了繼承父接口的泛型為List，所以再通過接口和父類獲取泛型信息時，是能正確的獲取。通過javap -v可以獲取對應的class信息

Java代碼

const #46 = Asciz   Lcom/agapple/misc/BaseGeneircInteface;>;Lcom/agapple/misc/GeneircInteface;>;Lcom/agapple/misc/CommonInteface;;

而在GenericClass中定義的方法method3，在class信息是一個被向上轉型后擦拭的信息。所以獲取method3的相關泛型信息是沒有的。

Java代碼

method3;     
const #36 = Asciz   (Ljava/lang/Object;)Ljava/lang/Object;;     
const #37 = Asciz   Exceptions;     
const #38 = class   #39;    //  java/lang/Throwable     
const #39 = Asciz   java/lang/Throwable;     
const #40 = Asciz   (TT;)TT;^TE;;     
const #41 = Asciz   TT;;

思考問題：

List list = new ArrayList(); 是否有獲取對應的String泛型信息? 不能，臨時變量不能保存泛型信息到具體class對象中，List和List對應的class實體是同一個。

Java代碼

GeneircInteface gi = new GeneircInteface() {     
    
            @Override    
            public Integer method1(Integer obj) {     
                return 1;     
            }     
    
        };

通過匿名類的方式，是否可以獲取Integer的泛型信息? 能，匿名類也會在進行class compiler保存泛型信息。

假如本文例子中的method3，是放在父類中BaseGeneircInteface中進行申明，GenericClass中指定R為List，是否可以獲取到對應的泛型信息? 不能，理由和問題1類似。

備注

具體泛型擦拭和信息保存，引用了撒迦的一段回復，解釋的挺詳盡了。

RednaxelaFX 寫道

Java泛型有這么一種規律：

位于聲明一側的，源碼里寫了什么到運行時就能看到什么;

位于使用一側的，源碼里寫什么到運行時都沒了。

什么意思呢?“聲明一側”包括泛型類型(泛型類與泛型接口)聲明、帶有泛型參數的方法和域的聲明。注意局部變量的聲明不算在內，那個屬于“使用”一側。

Java代碼

import java.util.List;      
import java.util.Map;      
    
public class GenericClass { // 1      
private List list; // 2      
private Map map; // 3      
    
public  U genericMethod(Map m) { // 4      
return null;      
}      
}

上面代碼里，帶有注釋的行里的泛型信息在運行時都還能獲取到，原則是源碼里寫了什么運行時就能得到什么。針對1的GenericClass，運行時通過Class.getTypeParameters()方法得到的數組可以獲取那個“T”;同理，2的T、3的java.lang.String與T、4的T與U都可以獲得。

這是因為從Java 5開始class文件的格式有了調整，規定這些泛型信息要寫到class文件中。以上面的map為例，通過javap來看它的元數據可以看到記錄了這樣的信息：

Javap代碼

private java.util.Map map;      
Signature: Ljava/util/Map;      
Signature: length = 0x2      
00 0A

乍一看，private java.util.Map map;不正好顯示了它的泛型類型被擦除了么?

但仔細看會發現有兩個Signature，下面的一個有兩字節的數據，0x0A。到常量池找到0x0A對應的項，是：

Javap代碼

const #10 = Asciz Ljava/util/Map;;

也就是內容為“Ljava/util/Map;”的一個字符串。

根據Java 5開始的新class文件格式規范，方法與域的描述符增添了對泛型信息的記錄，用一對尖括號包圍泛型參數，其中普通的引用類型用“La/b/c/D;”的格式記錄，未綁定值的泛型變量用“Txxx;”的格式記錄，其中xxx就是源碼中聲明的泛型變量名。類型聲明的泛型信息也以類似下面的方式記了下來：

Javap代碼

public class GenericClass extends java.lang.Object      
Signature: length = 0x2      
00 12      
// ...      
const #18 = Asciz Ljava/lang/Object;;

詳細信息請參考官方文檔：http://java.sun.com/docs/books/jvms/second_edition/ClassFileFormat-Java5.pdf

相比之下，“使用一側”的泛型信息則完全沒有被保留下來，在Java源碼編譯到class文件后就確實丟失了。也就是說，在方法體內的泛型局部變量、泛型方法調用之類的泛型信息編譯后都消失了。

Java代碼

import java.util.ArrayList;      
import java.util.List;      
    
public class TestClass {      
public static void main(String[] args) {      
List list = null; // 1      
list = new ArrayList(); // 2      
for (int i = 0; i < 10; i++) ;      
}      
}

上面代碼中，1留下的痕跡是：main()方法的StackMapTable屬性里可以看到：

Java代碼

StackMapTable: number_of_entries = 2      
frame_type = 253 /* append */      
offset_delta = 12      
locals = [ class java/util/List, int ]      
frame_type = 250 /* chop */      
offset_delta = 11

但這里是沒有留下泛型信息的。這段代碼只所以寫了個空的for循環就是為了迫使javac生成那個StackMapTable，讓1多留個影。

如果main()里用到了list的方法，那么那些方法調用點上也會留下1的痕跡，例如如果調用list.add("");，則會留下“java/util/List.add:(Ljava/lang/Object;)Z”這種記錄。

2留下的是“java/util/ArrayList."":()V”，同樣也丟失了泛型信息。

由上述討論可知，想對帶有未綁定的泛型變量的泛型類型獲取其實際類型是不現實的，因為class文件里根本沒記錄實際類型的信息。覺得這句話太拗口的話用例子來理解：要想對java.util.List獲取E的實際類型是不現實的，因為List.class文件里只記錄了E，卻沒記錄使用List時E的實際類型。

想對局部變量等“使用一側”的已綁定的泛型類型獲取其實際類型也不現實，同樣是因為class文件中根本沒記錄這個信息。例子直接看上面講“使用一側”的就可以了。

知道了什么信息有記錄，什么信息沒有記錄之后，也就可以省點力氣不去糾結“拿不到T的實際類型”、“建不出T類型的數組”之類的問題了orz

【編輯推薦】

Java泛型的理解與等價實現
Java泛型編程快速入門
淺談關于C#、Java泛型的看法
在Java中定義自己的工具庫
Java技術在協同軟件中的應用

責任編輯：金賀來源： JavaEye博客

java泛型