4.泛型與數(shù)據(jù)類型轉(zhuǎn)換
4.1. 消除類型轉(zhuǎn)換
上面的例子大家看到什么了，數(shù)據(jù)類型轉(zhuǎn)換的代碼不見了。在以前我們經(jīng)常要書寫以下代碼，如：
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable h = new Hashtable();
h.put("key", "value");
String s = (String)h.get("key");
System.out.println(s);
}
}
這個我們做了類型轉(zhuǎn)換，是不是感覺很煩的，并且強制類型轉(zhuǎn)換會帶來潛在的危險，系統(tǒng)可能會拋一個ClassCastException異常信息。在JDK5.0中我們完全可以這么做，如：
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable<String,Integer> h = new Hashtable<String,Integer> ();
h.put("key", new Integer(123));
int s = h.get("key").intValue();
System.out.println(s);
}
}
這里我們使用泛化版本的HashMap,這樣就不用我們來編寫類型轉(zhuǎn)換的代碼了，類型轉(zhuǎn)換的過程交給編譯器來處理，是不是很方便，而且很安全。上面是String映射到String，也可以將Integer映射為String，只要寫成HashTable<Integer,String> h=new HashTable<Integer,String>();h.get(new Integer(0))返回value。果然很方便。
4.2 自動解包裝與自動包裝的功能
從上面有沒有看到有點別扭啊，h.get(new Integer(123))這里的new Integer(123);好煩的，在JDK5.0之前我們只能忍著了，現(xiàn)在這種問題已經(jīng)解決了，請看下面這個方法。我們傳入一個int這一基本型別，然后再將i的值直接添加到List中，其實List是不能儲存基本型別的，List中應(yīng)該存儲對象，這里編譯器將int包裝成Integer，然后添加到List中去。接著我們用List.get(0);來檢索數(shù)據(jù)，并返回對象再將對象解包裝成int。恩，JDK5.0給我們帶來更多方便與安全。
public void autoBoxingUnboxing(int i) {
ArrayList<Integer> L= new ArrayList<Integer>();
L.add(i);
int a = L.get(0);
System.out.println("The value of i is " + a);
}
4.3 限制泛型中類型參數(shù)的范圍
也許你已經(jīng)發(fā)現(xiàn)在TestGen<K,V>這個泛型類,其中K,V可以是任意的型別。也許你有時候呢想限定一下K和V當(dāng)然范圍，怎么做呢？看看如下的代碼：
class TestGen2<K extents String,V extends Number>
{
private V v=null;
private K k=null;
public void setV(V v){
this.v=v;
}
public V getV(){
return this.v;
}
public void setK(K k){
this.k=k;
}
public V getK(){
return this.k;
}
public static void main(String[] args)
{
TestGen2<String,Integer> t2=new TestGen2<String,Integer>();
t2.setK(new String("String"));
t2.setV(new Integer(123));
System.out.println(t2.getK());
System.out.println(t2.getV());
}
}
上邊K的范圍是<=String ，V的范圍是<=Number，注意是“<=”,對于K可以是String的，V當(dāng)然也可以是Number，也可以是Integer,Float,Double,Byte等。看看下圖也許能直觀些請看上圖A是上圖類中的基類，A1，A2分別是A的子類，A2有2個子類分別是A2_1，A2_2。
然后我們定義一個受限的泛型類class MyGen<E extends A2>,這個泛型的范圍就是上圖中蘭色部分。
這個是單一的限制，你也可以對型別多重限制，如下：
class C<T extends Comparable<? super T> & Serializable>
我們來分析以下這句，T extends Comparable這個是對上限的限制，Comparable< super T>這個是下限的限制，Serializable是第2個上限。一個指定的類型參數(shù)可以具有一個或多個上限。具有多重限制的類型參數(shù)可以用于訪問它的每個限制的方法和域。
5.泛型方法
考慮寫一個持有數(shù)組類型對象和一個集合對象的方法，把數(shù)組里的所有對象都放到
集合里。第一個程序為：
static void fromArrayToColleciton(Object[]a,Collection<?> c){
for (Object o : a){
c.add(o);//編譯時錯誤
}
}
到現(xiàn)在為止，你可能學(xué)會避免開始的錯誤而去使用Collection<Object>作為集合參數(shù)的類型，你可能會意識到使用Colleciton<?>將不會工作。
解決這個問題的方法是使用泛型方法，GENERIC METHODS，就像類型聲明、方法聲明一樣，就是被一個或更多的類型參數(shù)參數(shù)化。
static <T> void fromArrayToCollection(T[]a,Collection<T> c){
for(T o :a){
c.add(o);//正確
}
}
我們可以用任意類型的集合調(diào)用這個方法，他的元素類型是數(shù)組元素類型的超類型。
Object[] oa = new Object[100];
Collection <Object> co = new ArrayList<Object>();
fromArrayToCollection(oa,co);//T 被認(rèn)為是Object類型
String[] sa = new String[100];
Colleciton<String> cs = new ArrayList<String>();
fromArrayToCollection(sa,cs);//T被認(rèn)為是String類型
fromArrayToCollection(sa,co);//T 被認(rèn)為是Object類型
Integer[] is = new Integer[100];
Float[] fa = new Float[100];
Number[] na = new Number[100];
Collection<Number> cn = new ArrayList<Number>();
fromArrayToCollection(is,cn);//Number
fromArrayToCollection(fa,cn);//Number
fromArrayToCollection(na,cn);//Number
fromArrayToCollection(na,co);//Object
fromArrayToCollection(na,cs);//編譯時錯誤
我們不必給一個泛型方法傳遞一個真正的類型參數(shù),編譯器會推斷類型參數(shù).一個問題出現(xiàn)了,什么時候使用泛型方法,什么時候使通配符類型,為了回答這些問題,我們從Colleciton庫中看一下幾個方法：
interface Collection<E>{
public boolean containsAll(Collection<?> c);
public boolean addAll(Collection<? extends E> c);
}
使用泛型方法的形式為：
interface Collection<E>{
public <T> boolean containsAll(Collection<T> c);
public <T extends E> boolean addAll(Collection<T> c);
}
無論如何，在ContainAll和addAll中，類型參數(shù)T僅被使用一次。返回類型不依賴于類型參數(shù)，也不依賴方法中的任何參數(shù)。這告訴我類型參數(shù)正被用于多態(tài)，它的影響僅僅是允許不同的實參在不同的調(diào)用點被使用。
泛型方法允許類型參數(shù)被用于表達在一個或更多參數(shù)之間或者方法中的參數(shù)、返回類型的依賴。如果沒有如此依賴，泛型方法就不能被使用。可能一前一后來聯(lián)合使用泛型和通配符，這里有個例子：
class Collections{
public static <T> void copy(List<T> dest,List<? extends T> src){
}
}
注意兩個參數(shù)之間的依賴，任何從原list的對象復(fù)制，必須分配一個目標(biāo)LIST元素的類型T,于是Src的元素類型可能是任何T的子類型。我們不必在意在COPY的表達中，表示依賴使用一個類型參數(shù)，但是是使用一個通配符。
下面我們不使用通配符來重寫上面的方法：
class Collections{
public static <T，S extends T>
void copy(List<T> dest,List<S> src){
}
}
這非常好，但是第一個類型參數(shù)既在dst中使用，也在第二個類型參數(shù)中使用，S本身就被使用了一次。在類型src中,沒有什么類型依賴它。這是一個標(biāo)志我們可以用通配符來替換它。使用通配符比顯示的聲明類型參數(shù)更加清楚和精確。所以有可能推薦使用通配符。
通配符也有優(yōu)勢，可以在方法之外來使用，作為字段類型、局部變量和數(shù)組。
這里有一個例子。
返回到我們畫圖的例子，假設(shè)我們要保持一個畫圖請求的歷史，我們可以在Shape類內(nèi)部用一個靜態(tài)變量來保持歷史。用drawAll()存儲它到來的參數(shù)到歷史字段。
static List<List<? extends Shape>> history =
new ArrayList<List<? extends Shape>>();
public void drawAll(List<? extends Shape> shapes){
history.addLast(shapes);
for (Shape s : shapes){
s.draw(this);
}
}