簡(jiǎn)介

Java 在 1.5 引入了泛型機(jī)制，泛型本質(zhì)是參數(shù)化類(lèi)型，也就是說(shuō)變量的類(lèi)型是一個(gè)參數(shù)，在使用時(shí)再指定為具體類(lèi)型。泛型可以用于類(lèi)、接口、方法，通過(guò)使用泛型可以使代碼更簡(jiǎn)單、安全。然而 Java 中的泛型使用了類(lèi)型擦除，所以只是偽泛型。這篇文章對(duì)泛型的使用以及存在的問(wèn)題做個(gè)總結(jié)，主要參考自 《Java 編程思想》。

這個(gè)系列的另外兩篇文章：

• Java 泛型總結(jié)（二）：泛型與數(shù)組
• Java 泛型總結(jié)（三）：通配符的使用

基本用法

泛型類(lèi)

如果有一個(gè)類(lèi) Holder 用于包裝一個(gè)變量，這個(gè)變量的類(lèi)型可能是任意的，怎么編寫(xiě) Holder 呢？在沒(méi)有泛型之前可以這樣：

public class Holder1 {
 private Object a;
 public Holder1(Object a) {
 this.a = a;
 }
 public void set(Object a) {
 this.a = a;
 }
 public Object get(){
 return a;
 }
 public static void main(String[] args) {
 Holder1 holder1 = new Holder1("not Generic");
 String s = (String) holder1.get();
 holder1.set(1);
 Integer x = (Integer) holder1.get();
 }
}

在 Holder1 中，有一個(gè)用 Object 引用的變量。因?yàn)槿魏晤?lèi)型都可以向上轉(zhuǎn)型為 Object，所以這個(gè) Holder 可以接受任何類(lèi)型。在取出的時(shí)候 Holder 只知道它保存的是一個(gè) Object 對(duì)象，所以要強(qiáng)制轉(zhuǎn)換為對(duì)應(yīng)的類(lèi)型。在 main 方法中， holder1 先是保存了一個(gè)字符串，也就是 String 對(duì)象，接著又變?yōu)楸４嬉粋€(gè) Integer 對(duì)象(參數(shù) 1 會(huì)自動(dòng)裝箱)。從 Holder 中取出變量時(shí)強(qiáng)制轉(zhuǎn)換已經(jīng)比較麻煩，這里還要記住不同的類(lèi)型，要是轉(zhuǎn)錯(cuò)了就會(huì)出現(xiàn)運(yùn)行時(shí)異常。

下面看看 Holder 的泛型版本：

public class Holder2<T> {
 private T a;
 public Holder2(T a) {
 this.a = a;
 }
 public T get() {
 return a;
 }
 public void set(T a) {
 this.a = a;
 }
 public static void main(String[] args) {
 Holder2<String> holder2 = new Holder2<>("Generic");
 String s = holder2.get();
 holder2.set("test");
 holder2.set(1);//無(wú)法編譯 參數(shù) 1 不是 String 類(lèi)型
 }
}

在 Holder2 中， 變量 a 是一個(gè)參數(shù)化類(lèi)型 T，T 只是一個(gè)標(biāo)識(shí)，用其它字母也是可以的。創(chuàng)建 Holder2 對(duì)象的時(shí)候，在尖括號(hào)中傳入了參數(shù) T 的類(lèi)型，那么在這個(gè)對(duì)象中，所有出現(xiàn) T 的地方相當(dāng)于都用 String 替換了?，F(xiàn)在的 get 的取出來(lái)的不是 Object ，而是 String 對(duì)象，因此不需要類(lèi)型轉(zhuǎn)換。另外，當(dāng)調(diào)用 set 時(shí)，只能傳入 String 類(lèi)型，否則編譯無(wú)法通過(guò)。這就保證了 holder2 中的類(lèi)型安全，避免由于不小心傳入錯(cuò)誤的類(lèi)型。

通過(guò)上面的例子可以看出泛使得代碼更簡(jiǎn)便、安全。引入泛型之后，Java 庫(kù)的一些類(lèi)，比如常用的容器類(lèi)也被改寫(xiě)為支持泛型，我們使用的時(shí)候都會(huì)傳入?yún)?shù)類(lèi)型，如：ArrayList<Integer> list = ArrayList<>();。

泛型方法

泛型不僅可以針對(duì)類(lèi)，還可以單獨(dú)使某個(gè)方法是泛型的，舉個(gè)例子：

public class GenericMethod {
 public <K,V> void f(K k,V v) {
 System.out.println(k.getClass().getSimpleName());
 System.out.println(v.getClass().getSimpleName());
 }
 public static void main(String[] args) {
 GenericMethod gm = new GenericMethod();
 gm.f(new Integer(0),new String("generic"));
 }
}

代碼輸出：
 Integer
 String

GenericMethod 類(lèi)本身不是泛型的，創(chuàng)建它的對(duì)象的時(shí)候不需要傳入泛型參數(shù)，但是它的方法 f 是泛型方法。在返回類(lèi)型之前是它的參數(shù)標(biāo)識(shí) <K,V>，注意這里有兩個(gè)泛型參數(shù)，所以泛型參數(shù)可以有多個(gè)。

調(diào)用泛型方法時(shí)可以不顯式傳入泛型參數(shù)，上面的調(diào)用就沒(méi)有。這是因?yàn)榫幾g器會(huì)使用參數(shù)類(lèi)型推斷，根據(jù)傳入的實(shí)參的類(lèi)型 (這里是 integer 和 String) 推斷出 K 和 V 的類(lèi)型。

類(lèi)型擦除

什么是類(lèi)型擦除

Java 的泛型使用了類(lèi)型擦除機(jī)制，這個(gè)引來(lái)了很大的爭(zhēng)議，以至于 Java 的泛型功能受到限制，只能說(shuō)是”偽泛型“。什么叫類(lèi)型擦除呢？簡(jiǎn)單的說(shuō)就是，類(lèi)型參數(shù)只存在于編譯期，在運(yùn)行時(shí)，Java 的虛擬機(jī) ( JVM ) 并不知道泛型的存在。先看個(gè)例子：

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);
 }
}

上面的代碼有兩個(gè)不同的 ArrayList：ArrayList<Integer> 和 ArrayList<String>。在我們看來(lái)它們的參數(shù)化類(lèi)型不同，一個(gè)保存整性，一個(gè)保存字符串。但是通過(guò)比較它們的 Class 對(duì)象，上面的代碼輸出是 true。這說(shuō)明在 JVM 看來(lái)它們是同一個(gè)類(lèi)。而在 C++、C# 這些支持真泛型的語(yǔ)言中，它們就是不同的類(lèi)。

泛型參數(shù)會(huì)擦除到它的第一個(gè)邊界，比如說(shuō)上面的 Holder2 類(lèi)，參數(shù)類(lèi)型是一個(gè)單獨(dú)的 T，那么就擦除到 Object,相當(dāng)于所有出現(xiàn) T 的地方都用 Object 替換。所以在 JVM 看來(lái)，保存的變量 a 還是 Object 類(lèi)型。之所以取出來(lái)自動(dòng)就是我們傳入的參數(shù)類(lèi)型，這是因?yàn)榫幾g器在編譯生成的字節(jié)碼文件中插入了類(lèi)型轉(zhuǎn)換的代碼，不需要我們手動(dòng)轉(zhuǎn)型了。如果參數(shù)類(lèi)型有邊界那么就擦除到它的第一個(gè)邊界，這個(gè)下一節(jié)再說(shuō)。

擦除帶來(lái)的問(wèn)題

擦除會(huì)出現(xiàn)一些問(wèn)題，下面是一個(gè)例子：

class HasF {
 public void f() {
 System.out.println("HasF.f()");
 }
}
public class Manipulator<T> {
 private T obj;
 public Manipulator(T obj) {
 this.obj = obj;
 }
 public void manipulate() {
 obj.f(); //無(wú)法編譯 找不到符號(hào) f()
 }
 public static void main(String[] args) {
 HasF hasF = new HasF();
 Manipulator<HasF> manipulator = new Manipulator<>(hasF);
 manipulator.manipulate();
 }
}

上面的 Manipulator 是一個(gè)泛型類(lèi)，內(nèi)部用一個(gè)泛型化的變量 obj，在 manipulate 方法中，調(diào)用了 obj 的方法 f()，但是這行代碼無(wú)法編譯。因?yàn)轭?lèi)型擦除，編譯器不確定 obj 是否有 f() 方法。解決這個(gè)問(wèn)題的方法是給 T 一個(gè)邊界:

class Manipulator2<T extends HasF> {
 private T obj;
 public Manipulator2(T x) { obj = x; }
 public void manipulate() { obj.f(); }
}

現(xiàn)在 T 的類(lèi)型是 <T extends HasF>，這表示 T 必須是 HasF 或者 HasF 的導(dǎo)出類(lèi)型。這樣，調(diào)用 f() 方法才安全。HasF 就是 T 的邊界，因此通過(guò)類(lèi)型擦除后，所有出現(xiàn) T 的

地方都用 HasF 替換。這樣編譯器就知道 obj 是有方法 f() 的。

但是這樣就抵消了泛型帶來(lái)的好處，上面的類(lèi)完全可以改成這樣：

class Manipulator3 {
 private HasF obj;
 public Manipulator3(HasF x) { obj = x; }
 public void manipulate() { obj.f(); }
}

所以泛型只有在比較復(fù)雜的類(lèi)中才體現(xiàn)出作用。但是像 <T extends HasF> 這種形式的東西不是完全沒(méi)有意義的。如果類(lèi)中有一個(gè)返回 T 類(lèi)型的方法，泛型就有用了，因?yàn)檫@樣會(huì)返回準(zhǔn)確類(lèi)型。比如下面的例子：

class ReturnGenericType<T extends HasF> {
 private T obj;
 public ReturnGenericType(T x) { obj = x; }
 public T get() { return obj; }
}

這里的 get() 方法返回的是泛型參數(shù)的準(zhǔn)確類(lèi)型，而不是 HasF。

類(lèi)型擦除的補(bǔ)償

類(lèi)型擦除導(dǎo)致泛型喪失了一些功能，任何在運(yùn)行期需要知道確切類(lèi)型的代碼都無(wú)法工作。比如下面的例子：

public class Erased<T> {
 private final int SIZE = 100;
 public static void f(Object arg) {
 if(arg instanceof T) {} // Error
 T var = new T(); // Error
 T[] array = new T[SIZE]; // Error
 T[] array = (T)new Object[SIZE]; // Unchecked warning
 }
}

通過(guò) new T() 創(chuàng)建對(duì)象是不行的，一是由于類(lèi)型擦除，二是由于編譯器不知道 T 是否有默認(rèn)的構(gòu)造器。一種解決的辦法是傳遞一個(gè)工廠對(duì)象并且通過(guò)它創(chuàng)建新的實(shí)例。

interface FactoryI<T> {
 T create();
}
class Foo2<T> {
 private T x;
 public <F extends FactoryI<T>> Foo2(F factory) {
 x = factory.create();
 }
 // ...
}
class IntegerFactory implements FactoryI<Integer> {
 public Integer create() {
 return new Integer(0);
 }
}
class Widget {
 public static class Factory implements FactoryI<Widget> {
 public Widget create() {
 return new Widget();
 }
 }
}
public class FactoryConstraint {
 public static void main(String[] args) {
 new Foo2<Integer>(new IntegerFactory());
 new Foo2<Widget>(new Widget.Factory());
 }
}

另一種解決的方法是利用模板設(shè)計(jì)模式：

abstract class GenericWithCreate<T> {
 final T element;
 GenericWithCreate() { element = create(); }
 abstract T create();
}
class X {}
class Creator extends GenericWithCreate<X> {
 X create() { return new X(); }
 void f() {
 System.out.println(element.getClass().getSimpleName());
 }
}
public class CreatorGeneric {
 public static void main(String[] args) {
 Creator c = new Creator();
 c.f();
 }
}

具體類(lèi)型的創(chuàng)建放到了子類(lèi)繼承父類(lèi)時(shí)，在 create 方法中創(chuàng)建實(shí)際的類(lèi)型并返回。

總結(jié)

本文介紹了 Java 泛型的使用，以及類(lèi)型擦除相關(guān)的問(wèn)題。一般情況下泛型的使用比較簡(jiǎn)單，但是某些情況下，尤其是自己編寫(xiě)使用泛型的類(lèi)或者方法時(shí)要注意類(lèi)型擦除的問(wèn)題。接下來(lái)會(huì)介紹數(shù)組與泛型的關(guān)系以及通配符的使用。

以上就是本文的全部?jī)?nèi)容，希望本文的內(nèi)容對(duì)大家的學(xué)習(xí)或者工作能帶來(lái)一定的幫助，同時(shí)也希望多多支持腳本之家！