【Java心得總結四】Java泛型下——萬惡的擦除

一、萬惡的擦除

我在自己總結的【Java心得總結三】Java泛型上——初識泛型這篇博文中提到了Java中對泛型擦除的問題，考慮下面代碼：

import java.util.*; 
public class ErasedTypeEquivalence { 
    public static void main(String[] args) { 
        Class c1 = new ArrayList<String>().getClass(); 
        Class c2 = new ArrayList<Integer>().getClass(); 
        System.out.println(c1 == c2); 
    } 
}/* Output: 
true 
*///:~ 

在代碼的第4行和第5行，我們分別定義了一個接受String類型的List和一個接受Integer類型的List，按照我們正常的理解，泛型ArrayList<T>雖然是相同的，但是我們給它傳了不同的類型參數，那么c1和2的類型應該是不同的。但是結果恰恰想法，運行程序發現二者的類型時相同的。這是為什么呢？這里就要說到Java語言實現泛型所獨有的——擦除（萬惡啊）

即當我們聲明List<String>和List<Integer>時，在運行時實際上是相同的，都是List，而具體的類型參數信息String和Integer被擦除了。這就導致一個很麻煩的問題：在泛型代碼內部，無法獲得任何有關泛型參數類型的信息 （摘自《Java編程思想第4版》）。

為了體驗萬惡的擦除的“萬惡”，我們與C++做一個比較：

C++模板：

#include <iostream> 
using namespace std; 
template<class T> class Manipulator { 
    T obj; 
    public: 
    Manipulator(T x) { obj = x; } 
    void manipulate() { obj.f(); } 
}; 
class HasF { 
    public: 
    void f() { cout << "HasF::f()" << endl; } 
}; 
int main() { 
    HasF hf; 
    Manipulator<HasF> manipulator(hf); 
    manipulator.manipulate(); 
} /* Output: 
HasF::f() 
///:~ 

在這段代碼中，我們聲明了一個模板（即泛型）類Manipulator，這個類接收一個T類型的對象，並在內部調用該對象的f方法，在main我們向Manipulator傳入一個擁有f方法的類HasF，然后代碼很正常的通過編譯而且順利運行。

C++代碼里其實有一個很奇怪的地方，就是在代碼第7行，我們利用傳入的T類型對象來調用它的f方法，那么我怎么知道你傳入的類型參數T類型是否有方法f呢？但是從整個編譯來看，C++中確實實現了，並且保證了整個代碼的正確性（可以驗證一個沒有方法f的類傳入，就會報錯）。至於怎么做到，我們稍后會略微提及。

OK，我們將這段代碼用Java實現下：

Java泛型：

public class HasF { 
    public void f() { System.out.println("HasF.f()"); } 
} 
class Manipulator<T> { 
    private T obj; 
    public Manipulator(T x) { obj = x; } 
    // Error: cannot find symbol: method f(): 
    public void manipulate() { obj.f(); } 
} 
public class Manipulation { 
    public static void main(String[] args) { 
        HasF hf = new HasF();
        Manipulator<HasF> manipulator = 
        new Manipulator<HasF>(hf); 
        manipulator.manipulate(); 
    } 
} ///:~

大家會發現在C++我們很方便就能實現的效果，在Java里無法辦到，在代碼第7行給出了錯誤提示，就是說在Manipulator內部我們無法獲知類型T是否含有方法f。這是為什么呢？就是因為萬惡的擦除引起的，在Java代碼運行的時候，它會將泛型類的類型信息T擦除掉，就是說運行階段，泛型類代碼內部完全不知道類型參數的任何信息。如上面代碼，運行階段Manipulator<HasF>類的類型信息會被擦除，只剩下Mainipulator，所以我們在Manipulator內部並不知道傳入的參數類型時HasF的，所以第8行代碼obj調用f自然就會報錯（就是我哪知道你有沒有f方法啊）

綜上，我們可以看出擦除帶來的代價：在泛型類或者說泛型方法內部，我們無法獲得任何類型信息，所以泛型不能用於顯示的引用運行時類型的操作之中，例如轉型、instanceof操作和new表達式。例如下代碼：

public class Animal<T>{
    T a;
    public Animal(T a){
        this.a = a;
    }
    // error!
    public void animalMove(){
        a.move();
    }
    // error!
    public void animalBark(){
        a.bark();
    }
    // error!
    public void animalNew(){
        return new T();
    }
    // error!
    public boolean isDog(){
        return T instanceof Dog;
    }
}
public class Dog{
    public void move(){
        System.out.println("dog move");
    }
    public void bark(){
        System.out.println("wang!wang!);
    }
}
public static void main(String[] args){
    Animal<Dog> ad = new Animal<Dog>();
}

我們聲明一個泛化的Animal類，之后聲明一個Dog類，Dog類可以移動move()，吠叫bark()。在main中將Dog作為類型參數傳遞給Animal<Dog>。而在代碼的第8行和第11行，我們嘗試調用傳入類的函數move()和bark()，發現會有錯誤；在代碼16行，我們試圖返回一個T類型的對象即new一個，也會得到錯誤；而在代碼20行，當我們試圖利用instanceof判斷T是否為Dog類型時，同樣是錯誤！

另外，我這里想強調下Java泛型是不支持基本類型的（基本類型可參見【Java心得總結一】Java基本類型和包裝類型解析）感謝CCQLegend

所以還是上面我們說過的話：在泛型代碼內部，無法獲得任何有關泛型參數類型的信息 （摘自《Java編程思想第4版》），我們在編寫泛化類的時候，我們要時刻提醒自己，我們傳入的參數T僅僅是一個Object類型，任何具體類型信息我們都是未知的。

二、為什么Java用擦除

上面我們簡單闡述了Java中泛型的一個擦除問題，也體會到它的萬惡，給我們編程帶來的不便。那Java開發者為什么要這么干呢？

這是一個歷史問題，Java在版本1.0中是不支持泛型的，這就導致了很大一批原有類庫是在不支持泛型的Java版本上創建的。而到后來Java逐漸加入了泛型，為了使得原有的非泛化類庫能夠在泛化的客戶端使用，Java開發者使用了擦除進行了折中。

所以Java使用這么具有局限性的泛型實現方法就是從非泛化代碼到泛化代碼的一個過渡，以及不破壞原有類庫的情況下，將泛型融入Java語言。

三、怎么解決擦除帶來的煩惱

解決方案1：

不要使用Java語言。這是廢話，但是確實，當你使用python和C++等語言，你會發現在這兩種語言中使用泛型是一件非常輕松加隨意的事情，而在Java中是事情要變得復雜得多。如下示例：

python：

class Dog: 
    def speak(self): 
    print "Arf!" 
    def sit(self): 
    print "Sitting" 
    def reproduce(self): 
    pass 
    
class Robot: 
    def speak(self): 
    print "Click!" 
    def sit(self): 
    print "Clank!" 
    def oilChange(self) : 
    pass 
    
def perform(anything): 
    anything.speak() 
    anything.sit()
    
a = Dog() 
b = Robot() 
perform(a) 
perform(b)

python的泛型使用簡直稱得上寫意，定義兩個類：Dog和Robot，然后直接用anything來聲明一個perform泛型方法，在這個泛型方法中我們分別調用了anything的speak()和sit()方法。

C++

class Dog { 
public: 
    void speak() {} 
    void sit() {} 
    void reproduce() {}
}; 

class Robot { 
    public: 
    void speak() {} 
    void sit() {} 
    void oilChange() { 
}; 

template<class T> void perform(T anything) { 
    anything.speak(); 
    anything.sit(); 
} 

int main() { 
    Dog d; 
    Robot r; 
    perform(d); 
    perform(r); 
} ///:~ 

C++中的聲明相對來說條條框框多一點，但是同樣能夠實現我們要達到的目的

Java：

public interface Performs { 
    void speak(); 
    void sit(); 
} ///:~ 
class PerformingDog extends Dog implements Performs { 
    public void speak() { print("Woof!"); } 
    public void sit() { print("Sitting"); } 
    public void reproduce() {} 
} 
class Robot implements Performs { 
    public void speak() { print("Click!"); } 
    public void sit() { print("Clank!"); } 
    public void oilChange() {} 
} 
class Communicate { 
    public static <T extends Performs> void perform(T performer) { 
        performer.speak(); 
        performer.sit(); 
    } 
} 
public class DogsAndRobots { 
    public static void main(String[] args) { 
        PerformingDog d = new PerformingDog(); 
        Robot r = new Robot(); 
        Communicate.perform(d); 
        Communicate.perform(r); 
    } 
}

Java代碼很奇怪的用到了一個接口Perform，然后在代碼16行定義泛型方法的時候指明了<T extends Perform>（泛型方法的聲明方式請見：【Java心得總結三】Java泛型上——初識泛型），聲明泛型的時候我們不是簡單的直接<T>而是確定了一個邊界，相當於告訴編譯器：傳入的這個類型一定是繼承自Perform接口的，那么T就一定有speak()和sit()這兩個方法，你就放心的調用吧。

可以看出Java的泛型使用方式很繁瑣，程序員需要考慮很多事情，不能夠按照正常的思維方式去處理。因為正常我們是這么想的：我定義一個接收任何類型的方法，然后在這個方法中調用傳入類型的一些方法，而你有沒有這個方法，那是編譯器要做的事情。

其實在python和C++中也是有這個接口的，只不過它是隱式的，程序員不需要自己去實現，編譯器會自動處理這個情況。

解決方案2：

當然啦，很多情況下我們還是要使用Java中的泛型的，怎么解決這個頭疼的問題呢？顯示的傳遞類型的Class對象：

從上面的分析我們可以看出Java的泛型類或者泛型方法中，對於傳入的類型參數的類型信息是完全丟失的，是被擦除掉的，我們在里面連個new都辦不到，這時候我們就可以利用Java的RTTI即運行時類型信息（后續博文）來解決，如下：

class Building {} 
class House extends Building {} 
public class ClassTypeCapture<T> { 
    Class<T> kind; 
    T t;
    public ClassTypeCapture(Class<T> kind) { 
        this.kind = kind; 
    } 
    public boolean f(Object arg) { 
        return kind.isInstance(arg); 
    }
    public void newT(){
        t = kind.newInstance();
    }
    public static void main(String[] args) { 
        ClassTypeCapture<Building> ctt1 = 
        new ClassTypeCapture<Building>(Building.class); 
        System.out.println(ctt1.f(new Building())); 
        System.out.println(ctt1.f(new House())); 
        ClassTypeCapture<House> ctt2 = 
        new ClassTypeCapture<House>(House.class); 
        System.out.println(ctt2.f(new Building())); 
        System.out.println(ctt2.f(new House())); 
    } 
}/* Output: 
true 
false 
true 
*///:~ 

在前面的例子中我們利用instanceof來判斷類型失敗，因為泛型中類型信息已經被擦除了，代碼第10行這里我們使用動態的isInstance()，並且傳入類型標簽Class<T>這樣的話我們只要在聲明泛型類時，利用構造函數將它的Class類型信息傳入到泛化類中，這樣就補償擦除問題

而在代碼第13行這里我們同樣可利用工廠對象Class對象來通過newInstance()方法得到一個T類型的實例。（這在C++中完全可以利用t = new T();實現，但是Java中丟失了類型信息，我無法知道T類型是否擁有無參構造函數）

（上面提到的Class、isInstance(),newInstance()等Java中類型信息的相關后續博文中我自己再總結）

解決方案3：

在解決方案1中我們提到了，利用邊界來解決Java對泛型的類型擦除問題。就是我們聲明一個接口，然后在聲明泛化類或者泛化方法的時候，顯示的告訴編譯器<T extends Interface>其中Interface是我們任意聲明的一個接口，這樣在內部我們就能夠知道T擁有哪些方法和T的部分類型信息。

四、通配符之協變、逆變

在使用Java中的容器的時候，我們經常會遇到類似List<? extends Fruit>這種聲明，這里問號?就是通配符。Fruit是一個水果類型基類，它的導出類型有Apple、Orange等等。

協變：

class Fruit {} 
class Apple extends Fruit {} 
class Jonathan extends Apple {} 
class Orange extends Fruit {} 
public class CovariantArrays { 
public static void main(String[] args) { 
    Fruit[] fruit = new Apple[10]; 
    fruit[0] = new Apple(); // OK 
    fruit[1] = new Jonathan(); // OK 
    // Runtime type is Apple[], not Fruit[] or Orange[]: 
    try { 
    // Compiler allows you to add Fruit: 
        fruit[0] = new Fruit(); // ArrayStoreException 
    } catch(Exception e) { System.out.println(e); } 
    try { 
    // Compiler allows you to add Oranges: 
        fruit[0] = new Orange(); // ArrayStoreException 
    } catch(Exception e) { System.out.println(e); } 
    } 
} /* Output: 
java.lang.ArrayStoreException: Fruit 
java.lang.ArrayStoreException: Orange 
*///:~

首先我們觀察一下數組當中的協變（協變就是子類型可以被當作基類型使用），Java數組是支持協變的。如上述代碼，我們會發現聲明的一個Apple數組用Fruit引用來存儲，但是當我們往里添加元素的時候我們只能添加Apple對象及其子類型的對象，如果試圖添加別的Fruit的子類型如Orange，那么在編譯器就會報錯，這是非常合理的，一個Apple類型的數組很明顯不能放Orange進去；但是在代碼13行我們會發現，如果想要將Fruit基類型的對象放入，編譯器是允許的，因為我們的數組引用是Fruit類型的，但是在運行時編譯器會發現實際上Fruit引用處理的是一個Apple數組，這是就會拋出異常。

然而我們把數組的這個操作翻譯到List上去，如下：

public class GenericsAndCovariance { 
    public static void main(String[] args) { 
        // Wildcards allow covariance: 
        List<? extends Fruit> flist = new ArrayList<Apple>(); 
        // Compile Error: can’t add any type of object: 
        // flist.add(new Apple()); 
        // flist.add(new Fruit()); 
        // flist.add(new Object()); 
        flist.add(null); // Legal but uninteresting 
        // We know that it returns at least Fruit: 
        Fruit f = flist.get(0); 
    } 
} ///:~ 

我們這里使用了通配符<? extends Fruit>，可以理解為：具有任何從Fruit繼承的類型的列表。我們會發現不僅僅是Orange對象不允許放入List，這時候極端的連Apple都不允許我們放入這個List中。這說明了一個問題List是不能像數組那樣擁有協變性。

這里為什么會出現這樣的情況，通過查看ArrayList的源碼我們會發現：當我們聲明ArrayList<? extends Fruit>中的add()的參數也變成了"? extends Fruit"，這時候編譯器無法知道你具體要添加的是Fruit的哪個具體子類型，那么它就會不接受任何類型的Fruit。

但是這里我們發現我們能夠正常的get()出一個元素的，很好理解，因為我們聲明的類型參數是<? extends Fruit>，編譯器肯定可以安全的將元素返回，應為我知道放在List中的一定是一個Fruit，那么返回就好。

逆變：

上面我們發現get方法是可以的，那么當我們想用set方法或者add方法的時候怎么辦？就可以使用逆變即超類型通配符。如下：

public class SuperTypeWildcards { 
    static void writeTo(List<? super Apple> apples) { 
        apples.add(new Apple()); 
        apples.add(new Jonathan()); 
        // apples.add(new Fruit()); // Error 
    } 
} ///:~ 

這里<? super Apple>意即這個List存放的是Apple的某種基類型，那么我將Apple或其子類型放入到這個List中肯定是安全的。

 

總結一下：

<? super T>逆變指明泛型類持有T的基類，則T肯定可以放入

<? extends T>指明泛型類持有T的導出類，則返回值一定可作為T的協變類型返回

 

說了這么多，總結了一堆也發現了Java泛型真的很渣，不好用，對程序員的要求會更高一些，一不小心就會出錯。這也就是我們使用類庫中的泛化類時常看到各種各樣的警告的原因了。。。

 

參考——《Java編程思想第4版》

上面在通配符這里本人理解還不是很透徹，以后我也會根據自己理解修改整理。