.NET中的泛型和Java泛型中的類型擦除

開放類型和閉合類型

.NET把帶有類型參數的類型看做一個新的類型，CLR將為這些類型創建內部類型對象，帶有類型參數的類型可以是類，結構，接口和委托。但是，一個帶有類型參數的類型稱為開放類型，CLR不允許開放類型實例化(就好比不允許接口實例化一樣)。

當代碼中引用了泛型類型，代碼里可以指定一組泛型類型參數。如果傳入實際的數據類型，那么這個類型就成為閉合類型，CLR允許實例化閉合類型。然而，也有可能代碼引用了泛型類型，但未指定泛型類型參數，這就在CLR中創建了一個新的開放類型，這種類型無法實例化，看一個例子。

internal sealed class DictionaryStringKey<TValue> :Dictionary<String, TValue> 
        { 
        } 
        static void Main(string[] args) 
        { 
            Object o = null; 
            // Dictionary<,> 有2個類型參數的開放類型 
            Type t = typeof(Dictionary<,>); 
            // 創建實例會失敗 
            o = CreateInstance(t); 
            Console.WriteLine(); 
            // DictionaryStringKey<>有一個類型參數的開發類型 
            t = typeof(DictionaryStringKey<>); 
            // 創建該類型的實例也會失敗 
            o = CreateInstance(t); 
            Console.WriteLine(); 
            // DictionaryStringKey<Guid> 是閉合類型 
            t = typeof(DictionaryStringKey<Guid>); 
            // 創建成功 
            o = CreateInstance(t); 
            // 輸出類型名字 
            Console.WriteLine("Object type=" + o.GetType()); 
        } 
        private static Object CreateInstance(Type t) 
        { 
            Object o = null; 
            try 
            { 
                //使用默認的構造函數來創造該類型的實例 
                o = Activator.CreateInstance(t); 
                Console.Write("Created instance of {0}", t.ToString()); 
            } 
            catch (ArgumentException e) 
            { 
                Console.WriteLine(e.Message); 
            } 
            return o; 
        } 

運行結果：

Activator.CreateInstance創建實例的時候，會提示你該類型包含泛型參數。

輸出中，可以看到類型名稱后跟著反引號（`）以及一個數字。這個數字即類型中的類型參數的數量。比如泛型Dictionary類是2，因為它需要2個類型參數來指示TKey和TValue。DictionaryStringKey類只有1個因為它只需要指明1個類型TValue。

.NET中的類型

.net中，除了實例構造器，CLR也支持類型構造器（也稱作靜態夠器，類夠在其或者類型初始化器）。類型構造器可以應用于接口（c#中不支持），引用類型（class）和值類型（struct），和實例構造器初始化類型的實例一樣，類型構造器用來初始化類型的一些狀態，類型的構造器如果有的話 只可能有1個，并且是無參的。可以參考之前的文章。

http://cnn237111.blog.51cto.com/2359144/576533

由于CLR保證了類型初始化器只執行一次，并且是線程安全的，因此類型初始化器適用于用在單例模式中對單例對象的初始化。

類型中的靜態字段可以認為是類型的一部分，而類型中的非靜態字段可以認為是實例對象的一部分。當JIT編譯器把IL語言轉換成本地的CPU指令的時候，會遇到很多類型（比如自定義的class），CLR為了能正確的加載包含這些類型的程序集，它會通過程序集的元數據，抽取出類型的信息，然后創建這些類型的數據數據結構。這些數據結構作為對象存放在堆中。堆中所有的對象都有2個成員，類型對象指針和同步塊索引。類型中定義的靜態字段也包含在數據結構對象中。類的實例對象都共享類型對象中同一個靜態字段。如下圖：方框中的Manager是類型對象，靜態字段存在于類型對象中。實例對象由橢圓框表示，指向類型對象。

對于.NET泛型來說，每一個閉合類型都有自己的靜態字段。也就是說List<>和List<String>中的靜態字段是互相獨立的。同樣的，如果泛型類型定義了一個靜態構造器，這些構造器也是按照各自的閉合類型運行。也就是說，List<DateTime>和List<String>有自己獨立的靜態構造器。

static void Main(string[] args) 
        { 
            bool issame = typeof(List<DateTime>) == typeof(List<string>); 
            Console.WriteLine(issame); 
            object o = Activator.CreateInstance(typeof(List<DateTime>)); 
            Console.WriteLine(o.GetType()); 
            o = Activator.CreateInstance(typeof(List<string>)); 
            Console.WriteLine(o.GetType()); 
        } 

運行結果如下：

Java泛型中的類型擦除

  經常聽人說起Java的泛型是偽泛型，因為在編譯或運行期間，java的JIT會對進行類型擦除。即JVM無法真正識別出泛型類型，因此在真正運行前會把泛型類型轉換成原始類型。因此，所有的泛型類型，本質上都共享同一個類型對象。比如List<Integer>類型在擦除后變成非泛型的List，這個List可以存放任何類型的數據。因此，Java在運行的時候，無法獲得類型。當然，使用反射也許可以知道，但是并不保證總是能夠得到類型。因此在Java代碼中，不同的泛型類型其實都是出自相同的類型。例如下面代碼：

public static void main(String[] args) throws Exception { 
  List<Integer> li = new ArrayList<Integer>(); 
  List<Float> lf = new ArrayList<Float>(); 
  boolean issame = li.getClass() == lf.getClass(); 
  System.out.println(issame);//true 
  Object o = li.getClass().newInstance(); 
  System.out.println(o.getClass().getName());//java.util.ArrayList 
  o = lf.getClass().newInstance(); 
  System.out.println(o.getClass().getName());//java.util.ArrayList 
} 

也正是由于代碼擦除，使得泛型類型本質上都是共享同一個類型對象，因此類型的靜態字段也是共享的。例如下面代碼：

public class AtestClass<E> { 
public static int i=0; 
public AtestClass() 
{ 
i++; 
} 
} 
 
------------------ 
 
public static void main(String[] args) throws Exception { 
   AtestClass<Integer> ai=new AtestClass<Integer>(); 
   AtestClass<Float> af=new AtestClass<Float>(); 
   System.out.println(AtestClass.i); 
} 

最終運行的結果是2.

參考文檔:Microsoft.Press.CLR.via.Csharp.4th.Edition.Oct.2012.

https://en.wikipedia.org/wiki/Generics_in_Java.