引言
泛型是JAVA中一個(gè)非常重要的知識(shí)點(diǎn),在Java集合類(lèi)框架中泛型被廣泛應(yīng)用。本文我們將從零開(kāi)始來(lái)看一下Java泛型的設(shè)計(jì),將會(huì)涉及到通配符處理,以及讓人苦惱的類(lèi)型擦除。
作者: ZiWenXie http://www.ziwenxie.site/2017/03/01/java-generic/
泛型基礎(chǔ)
泛型類(lèi)
我們首先定義一個(gè)簡(jiǎn)單的Box類(lèi):
public class Box { private String object; public void set(String object) { this.object = object; } public String get() { return object; } }
這是最常見(jiàn)的做法,這樣做的一個(gè)壞處是Box里面現(xiàn)在只能裝入String類(lèi)型的元素,今后如果我們需要裝入Integer等其他類(lèi)型的元素,還必須要另外重寫(xiě)一個(gè)Box,代碼得不到復(fù)用,使用泛型可以很好的解決這個(gè)問(wèn)題。
public class Box<T> { private T t; public void set(T t) { this.t = t; } public T get() { return t; } }
這樣我們的Box類(lèi)便可以得到復(fù)用,我們可以將T替換成任何我們想要的類(lèi)型:
Box<Integer> integerBox = new Box<Integer>(); Box<Double> doubleBox = new Box<Double>(); Box<String> stringBox = new Box<String>();
泛型方法
看完了泛型類(lèi),接下來(lái)我們來(lái)了解一下泛型方法。聲明一個(gè)泛型方法很簡(jiǎn)單,只要在返回類(lèi)型前面加上一個(gè)類(lèi)似的形式就行了:
public class Util { public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) { return p1.getKey().equals(p2.getKey()) && p1.getValue().equals(p2.getValue()); } } public class Pair<K, V> { private K key; private V value; public Pair(K key, V value) { this.key = key; this.value = value; } public void setKey(K key) { this.key = key; } public void setValue(V value) { this.value = value; } public K getKey() { return key; } public V getValue() { return value; } }
我們可以像下面這樣去調(diào)用泛型方法:
Pair<Integer, String> p1 = new Pair<>(1, "Apple"); Pair<Integer, String> p2 = new Pair<>(2, "pear"); boolean same = Util.< Integer, String>compare(p1, p2);
或者在Java1.7/1.8利用type inference,讓Java自動(dòng)推導(dǎo)出相應(yīng)的類(lèi)型參數(shù):
Pair<Integer, String> p1 = new Pair<>(1, "apple"); Pair<Integer, String> p2 = new Pair<>(2, "pear"); boolean same = Util.compare(p1, p2);
邊界符
現(xiàn)在我們要實(shí)現(xiàn)這樣一個(gè)功能,查找一個(gè)泛型數(shù)組中大于某個(gè)特定元素的個(gè)數(shù),我們可以這樣實(shí)現(xiàn):
public static <T> int countGreaterThan(T[] anArray, T elem) { int count = 0; for (T e :anArray) if (e > elem) ++count; return count; }
但是這樣很明顯是錯(cuò)誤的,因?yàn)槌藄hort, int, double, long, float, byte, char等原始類(lèi)型,其他的類(lèi)并不一定能使用操作符>,所以編譯器報(bào)錯(cuò),那怎么解決這個(gè)問(wèn)題呢?答案是使用邊界符。
public interface Comparable<T> { public int compareTo(T o); }
做一個(gè)類(lèi)似于下面這樣的聲明,這樣就等于告訴編譯器類(lèi)型參數(shù)T代表的都是實(shí)現(xiàn)了Comparable接口的類(lèi),這樣等于告訴編譯器它們都至少實(shí)現(xiàn)了compareTo方法。
public static <T extends Comparable <T>> int countGreaterThan(T[] anArray, T elem) { int count = 0 ; for (T e :anArray) if (e.compareTo(elem) > 0 ) ++count; return count; }
通配符
在了解通配符之前,我們首先必須要澄清一個(gè)概念,還是借用我們上面定義的Box類(lèi),假設(shè)我們添加一個(gè)這樣的方法:
public void boxTest( Box < Number > n) { }
那么現(xiàn)在Box n允許接受什么類(lèi)型的參數(shù)?我們是否能夠傳入Box或者Box呢?答案是否定的,雖然Integer和Double是Number的子類(lèi),但是在泛型中Box或者Box與Box之間并沒(méi)有任何的關(guān)系。這一點(diǎn)非常重要,接下來(lái)我們通過(guò)一個(gè)完整的例子來(lái)加深一下理解。面試官問(wèn):Java中的鎖有哪些?我跪了……
首先我們先定義幾個(gè)簡(jiǎn)單的類(lèi),下面我們將用到它:
class Fruit {} public class GenericReading { static List < Apple > apples = Arrays .asList( new Apple ()); static List < Fruit > fruit = Arrays .asList( new Fruit ()); static class Reader <T> { T readExact( List <T> list) { return list. get ( 0 ); } } static void f1() { static class CovariantReader <T> { T readCovariant( List <? extends T> list) { return list. get ( 0 ); } } static void f2() { CovariantReader < Fruit > fruitReader = new CovariantReader < Fruit >(); Fruit f = fruitReader.readCovariant(fruit); Fruit a = fruitReader.readCovariant(apples); } public static void main( String [] args) { f2(); }
這樣就相當(dāng)與告訴編譯器, fruitReader的readCovariant方法接受的參數(shù)只要是滿(mǎn)足Fruit的子類(lèi)就行(包括Fruit自身),這樣子類(lèi)和父類(lèi)之間的關(guān)系也就關(guān)聯(lián)上了。
PECS原則
上面我們看到了類(lèi)似的用法,利用它我們可以從list里面get元素,那么我們可不可以往list里面add元素呢?我們來(lái)嘗試一下:
public class GenericsAndCovariance { public static void main( String [] args) { List <? extends Fruit > flist = new ArrayList < Apple >(); flist.add( null ); Fruit f = flist. get ( 0 ); } }
答案是否定,Java編譯器不允許我們這樣做,為什么呢?對(duì)于這個(gè)問(wèn)題我們不妨從編譯器的角度去考慮。因?yàn)長(zhǎng)istflist它自身可以有多種含義:
List <? extends Fruit > flist = new ArrayList < Fruit >(); List <? extends Fruit > flist = new ArrayList < Apple >(); List <? extends Fruit > flist = new ArrayList < Orange >();
當(dāng)我們嘗試add一個(gè)Apple的時(shí)候,flist可能指向new ArrayList();
當(dāng)我們嘗試add一個(gè)Orange的時(shí)候,flist可能指向new ArrayList();
當(dāng)我們嘗試add一個(gè)Fruit的時(shí)候,這個(gè)Fruit可以是任何類(lèi)型的Fruit,而flist可能只想某種特定類(lèi)型的Fruit,編譯器無(wú)法識(shí)別所以會(huì)報(bào)錯(cuò)。華為 Java 編程軍規(guī),牛逼!
所以對(duì)于實(shí)現(xiàn)了的集合類(lèi)只能將它視為Producer向外提供(get)元素,而不能作為Consumer來(lái)對(duì)外獲取(add)元素。
如果我們要add元素應(yīng)該怎么做呢?可以使用:
public class GenericWriting { static List < Apple > apples = new ArrayList < Apple >(); static List < Fruit > fruit = new ArrayList < Fruit >(); static <T> void writeExact( List <T> list, T item) { list.add(item); } static void f1() { writeExact(apples, new Apple ()); writeExact(fruit, new Apple ()); } static <T> void writeWithWildcard( List <? super T> list, T item) { list.add(item) } static void f2() { writeWithWildcard(apples, new Apple ()); writeWithWildcard(fruit, new Apple ()); } public static void main( String [] args) { f1(); f2(); } }
這樣我們可以往容器里面添加元素了,但是使用super的壞處是以后不能get容器里面的元素了,原因很簡(jiǎn)單,我們繼續(xù)從編譯器的角度考慮這個(gè)問(wèn)題,對(duì)于List list,它可以有下面幾種含義:
List <? super Apple > list = new ArrayList < Apple >(); List <? super Apple > list = new ArrayList < Fruit >(); List <? super Apple > list = new ArrayList < Object >();
當(dāng)我們嘗試通過(guò)list來(lái)get一個(gè)Apple的時(shí)候,可能會(huì)get得到一個(gè)Fruit,這個(gè)Fruit可以是Orange等其他類(lèi)型的Fruit。
根據(jù)上面的例子,我們可以總結(jié)出一條規(guī)律,”Producer Extends, Consumer Super”:
“Producer Extends” – 如果你需要一個(gè)只讀List,用它來(lái)produce T,那么使用? extends T。
“Consumer Super” – 如果你需要一個(gè)只寫(xiě)List,用它來(lái)consume T,那么使用? super T。
如果需要同時(shí)讀取以及寫(xiě)入,那么我們就不能使用通配符了。
如何閱讀過(guò)一些Java集合類(lèi)的源碼,可以發(fā)現(xiàn)通常我們會(huì)將兩者結(jié)合起來(lái)一起用,比如像下面這樣:
public class Collections { public static <T> void copy( List <? super T> dest, List <? extends T> src) { for ( int i= 0 ; i<src.size(); i++) dest. set (i, src. get (i)); } }
類(lèi)型擦除
Java泛型中最令人苦惱的地方或許就是類(lèi)型擦除了,特別是對(duì)于有C++經(jīng)驗(yàn)的程序員。類(lèi)型擦除就是說(shuō)Java泛型只能用于在編譯期間的靜態(tài)類(lèi)型檢查,然后編譯器生成的代碼會(huì)擦除相應(yīng)的類(lèi)型信息,這樣到了運(yùn)行期間實(shí)際上JVM根本就知道泛型所代表的具體類(lèi)型。這樣做的目的是因?yàn)镴ava泛型是1.5之后才被引入的,為了保持向下的兼容性,所以只能做類(lèi)型擦除來(lái)兼容以前的非泛型代碼。對(duì)于這一點(diǎn),如果閱讀Java集合框架的源碼,可以發(fā)現(xiàn)有些類(lèi)其實(shí)并不支持泛型。別亂打日志了,這才是正確的打日志姿勢(shì)!
說(shuō)了這么多,那么泛型擦除到底是什么意思呢?我們先來(lái)看一下下面這個(gè)簡(jiǎn)單的例子:
public class Node <T> { private T data; private Node <T> next ; public Node (T data, Node <T> next ) { this .data = data; this . next = next ; } public T getData() { return data; } }
編譯器做完相應(yīng)的類(lèi)型檢查之后,實(shí)際上到了運(yùn)行期間上面這段代碼實(shí)際上將轉(zhuǎn)換成:
public class Node { private Object data; private Node next ; public Node ( Object data, Node next ) { this .data = data; this . next = next ; } public Object getData() { return data; } }
這意味著不管我們聲明Node還是Node,到了運(yùn)行期間,JVM統(tǒng)統(tǒng)視為Node。有沒(méi)有什么辦法可以解決這個(gè)問(wèn)題呢?這就需要我們自己重新設(shè)置bounds了,將上面的代碼修改成下面這樣:
public class Node <T extends Comparable <T>> { private T data; private Node <T> next ; public Node (T data, Node <T> next ) { this .data = data; this . next = next ; } public T getData() { return data; } }
這樣編譯器就會(huì)將T出現(xiàn)的地方替換成Comparable而不再是默認(rèn)的Object了:
public class Node { private Comparable data; private Node next ; public Node ( Comparable data, Node next ) { this .data = data; this . next = next ; } public Comparable getData() { return data; } }
上面的概念或許還是比較好理解,但其實(shí)泛型擦除帶來(lái)的問(wèn)題遠(yuǎn)遠(yuǎn)不止這些,接下來(lái)我們系統(tǒng)地來(lái)看一下類(lèi)型擦除所帶來(lái)的一些問(wèn)題,有些問(wèn)題在C++的泛型中可能不會(huì)遇見(jiàn),但是在Java中卻需要格外小心。
問(wèn)題一
在Java中不允許創(chuàng)建泛型數(shù)組,類(lèi)似下面這樣的做法編譯器會(huì)報(bào)錯(cuò):
List < Integer >[] arrayOfLists = new List < Integer >[ 2 ];
為什么編譯器不支持上面這樣的做法呢?繼續(xù)使用逆向思維,我們站在編譯器的角度來(lái)考慮這個(gè)問(wèn)題。
我們先來(lái)看一下下面這個(gè)例子:
Object [] strings = new String [ 2 ]; strings[ 0 ] = "hi" ; strings[ 1 ] = 100 ;
對(duì)于上面這段代碼還是很好理解,字符串?dāng)?shù)組不能存放整型元素,而且這樣的錯(cuò)誤往往要等到代碼運(yùn)行的時(shí)候才能發(fā)現(xiàn),編譯器是無(wú)法識(shí)別的。接下來(lái)我們?cè)賮?lái)看一下假設(shè)Java支持泛型數(shù)組的創(chuàng)建會(huì)出現(xiàn)什么后果:
Object [] stringLists = new List < String >[]; stringLists[ 0 ] = new ArrayList < String >(); stringLists[ 1 ] = new ArrayList < Integer >();
假設(shè)我們支持泛型數(shù)組的創(chuàng)建,由于運(yùn)行時(shí)期類(lèi)型信息已經(jīng)被擦除,JVM實(shí)際上根本就不知道new ArrayList()和new ArrayList()的區(qū)別。類(lèi)似這樣的錯(cuò)誤假如出現(xiàn)才實(shí)際的應(yīng)用場(chǎng)景中,將非常難以察覺(jué)。別亂打日志了,這才是正確的打日志姿勢(shì)!
如果你對(duì)上面這一點(diǎn)還抱有懷疑的話(huà),可以嘗試運(yùn)行下面這段代碼:
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); } }
問(wèn)題二
繼續(xù)復(fù)用我們上面的Node的類(lèi),對(duì)于泛型代碼,Java編譯器實(shí)際上還會(huì)偷偷幫我們實(shí)現(xiàn)一個(gè)Bridge method。
public class Node <T> { public T data; public Node (T data) { this .data = data; } public void setData(T data) { System . out .println( "Node.setData" ); this .data = data; } } public class MyNode extends Node < Integer > { public MyNode ( Integer data) { super (data); } public void setData( Integer data) { System . out .println( "MyNode.setData" ); super .setData(data); } }
看完上面的分析之后,你可能會(huì)認(rèn)為在類(lèi)型擦除后,編譯器會(huì)將Node和MyNode變成下面這樣:
public class Node { public Object data; public Node ( Object data) { this .data = data; } public void setData( Object data) { System . out .println( "Node.setData" ); this .data = data; } } public class MyNode extends Node { public MyNode ( Integer data) { super (data); } public void setData( Integer data) { System . out .println( "MyNode.setData" ); super .setData(data); } }
實(shí)際上不是這樣的,我們先來(lái)看一下下面這段代碼,這段代碼運(yùn)行的時(shí)候會(huì)拋出ClassCastException異常,提示String無(wú)法轉(zhuǎn)換成Integer:
MyNode mn = new MyNode ( 5 ); Node n = mn; n.setData( "Hello" );
如果按照我們上面生成的代碼,運(yùn)行到第3行的時(shí)候不應(yīng)該報(bào)錯(cuò)(注意我注釋掉了第4行),因?yàn)镸yNode中不存在setData(String data)方法,所以只能調(diào)用父類(lèi)Node的setData(Object data)方法,既然這樣上面的第3行代碼不應(yīng)該報(bào)錯(cuò),因?yàn)镾tring當(dāng)然可以轉(zhuǎn)換成Object了,那ClassCastException到底是怎么拋出的?
實(shí)際上Java編譯器對(duì)上面代碼自動(dòng)還做了一個(gè)處理:
class MyNode extends Node { public void setData( Object data) { setData(( Integer ) data); } public void setData( Integer data) { System . out .println( "MyNode.setData" ); super .setData(data); } }
這也就是為什么上面會(huì)報(bào)錯(cuò)的原因了,setData((Integer) data);的時(shí)候String無(wú)法轉(zhuǎn)換成Integer。所以上面第2行編譯器提示unchecked warning的時(shí)候,我們不能選擇忽略,不然要等到運(yùn)行期間才能發(fā)現(xiàn)異常。如果我們一開(kāi)始加上Node n = mn就好了,這樣編譯器就可以提前幫我們發(fā)現(xiàn)錯(cuò)誤。
問(wèn)題三
正如我們上面提到的,Java泛型很大程度上只能提供靜態(tài)類(lèi)型檢查,然后類(lèi)型的信息就會(huì)被擦除,所以像下面這樣利用類(lèi)型參數(shù)創(chuàng)建實(shí)例的做法編譯器不會(huì)通過(guò):
public static <E> void append( List <E> list) { E elem = new E(); list.add(elem); }
但是如果某些場(chǎng)景我們想要需要利用類(lèi)型參數(shù)創(chuàng)建實(shí)例,我們應(yīng)該怎么做呢?可以利用反射解決這個(gè)問(wèn)題:
public static <E> void append( List <E> list, Class <E> cls) throws Exception { E elem = cls.newInstance(); list.add(elem); }
我們可以像下面這樣調(diào)用:
List < String > ls = new ArrayList <>(); append(ls, String . class );
實(shí)際上對(duì)于上面這個(gè)問(wèn)題,還可以采用Factory和Template兩種設(shè)計(jì)模式解決,感興趣的朋友不妨去看一下Thinking in Java中第15章中關(guān)于Creating instance of types(英文版第664頁(yè))的講解,這里我們就不深入了。
問(wèn)題四
我們無(wú)法對(duì)泛型代碼直接使用instanceof關(guān)鍵字,因?yàn)镴ava編譯器在生成代碼的時(shí)候會(huì)擦除所有相關(guān)泛型的類(lèi)型信息,正如我們上面驗(yàn)證過(guò)的JVM在運(yùn)行時(shí)期無(wú)法識(shí)別出ArrayList和ArrayList的之間的區(qū)別:
public static <E> void rtti( List <E> list) { if (list instanceof ArrayList < Integer >) { } } => { ArrayList < Integer >, ArrayList < String >, LinkedList < Character >, ... }
和上面一樣,我們可以使用通配符重新設(shè)置bounds來(lái)解決這個(gè)問(wèn)題:
public static void rtti( List <?> list) { if (list instanceof ArrayList <?>) { } }
工廠(chǎng)模式
接下來(lái)我們利用泛型來(lái)簡(jiǎn)單的實(shí)現(xiàn)一下工廠(chǎng)模式,首先我們先聲明一個(gè)接口Factory:
package typeinfo.factory; public interface Factory <T> { T create(); }
接下來(lái)我們來(lái)創(chuàng)建幾個(gè)實(shí)體類(lèi)FuelFilter和AirFilter以及FanBelt和GeneratorBelt。
class Filter extends Part {} class FuelFilter extends Filter { public static class Factory implements typeinfo.factory. Factory < FuelFilter > { public FuelFilter create() { return new FuelFilter (); } } } class AirFilter extends Filter { public static class Factory implements typeinfo.factory. Factory < AirFilter > { public AirFilter create() { return new AirFilter (); } } } class Belt extends Part {} class FanBelt extends Belt { public static class Factory implements typeinfo.factory. Factory < FanBelt > { public FanBelt create() { return new FanBelt (); } } } class GeneratorBelt extends Belt { public static class Factory implements typeinfo.factory. Factory < GeneratorBelt > { public GeneratorBelt create() { return new GeneratorBelt (); } } }
Part類(lèi)的實(shí)現(xiàn)如下,注意我們上面的實(shí)體類(lèi)都是Part類(lèi)的間接子類(lèi)。在Part類(lèi)我們注冊(cè)了我們上面的聲明的實(shí)體類(lèi)。所以以后我們?nèi)绻獎(jiǎng)?chuàng)建相關(guān)的實(shí)體類(lèi)的話(huà),只需要在調(diào)用Part類(lèi)的相關(guān)方法了。這么做的一個(gè)好處就是如果的業(yè)務(wù)中出現(xiàn)了CabinAirFilter或者PowerSteeringBelt的話(huà),我們不需要修改太多的代碼,只需要在Part類(lèi)中將它們注冊(cè)即可。老大難的空指針,如何優(yōu)雅處理?
class Part { static List < Factory <? extends Part >> partFactories = new ArrayList < Factory <? extends Part >>(); static { partFactories.add( new FuelFilter . Factory ()); partFactories.add( new AirFilter . Factory ()); partFactories.add( new FanBelt . Factory ()); partFactories.add( new PowerSteeringBelt . Factory ()); } private static Random rand = new Random ( 47 ); public static Part createRandom() { int n = rand.nextInt(partFactories.size()); return partFactories. get (n).create(); } public String toString() { return getClass().getSimpleName(); } }
最后我們來(lái)測(cè)試一下:
public class RegisteredFactories { public static void main(String[] args) { for (int i = 0; i < 10; i++) { System.out.println(Part.createRandom()); } } }
References
- ORACLE-DOCUMENTATION
- THINKING IN JAVA
- EFFECTIVE JAVA