Java 泛型(generics)是 JDK 5 中引入的一個新特性, 泛型提供了編譯時類型安全檢測機制,該機制容許程序員在編譯時檢測到非法的類型。
泛型的本質是參數化類型,也就是說所操做的數據類型被指定爲一個參數。java
你能夠寫一個泛型方法,該方法在調用時能夠接收不一樣類型的參數。根據傳遞給泛型方法的參數類型,編譯器適當地處理每個方法調用。程序員
下面是定義泛型方法的規則:數組
有界的類型參數:
可能有時候,你會想限制那些被容許傳遞到一個類型參數的類型種類範圍。例如,一個操做數字的方法可能只但願接受Number或者Number子類的實例。這就是有界類型參數的目的。安全
要聲明一個有界的類型參數,首先列出類型參數的名稱,後跟extends關鍵字,最後緊跟它的上界。app
public class GenericTest { //這個類是個泛型類,在上面已經介紹過 public class Generic<T>{ private T key; public Generic(T key) { this.key = key; } //我想說的實際上是這個,雖然在方法中使用了泛型,可是這並非一個泛型方法。 //這只是類中一個普通的成員方法,只不過他的返回值是在聲明泛型類已經聲明過的泛型。 //因此在這個方法中才能夠繼續使用 T 這個泛型。 public T getKey(){ return key; } /** * 這個方法顯然是有問題的,在編譯器會給咱們提示這樣的錯誤信息"cannot reslove symbol E" * 由於在類的聲明中並未聲明泛型E,因此在使用E作形參和返回值類型時,編譯器會沒法識別。 public E setKey(E key){ this.key = keu } */ } /** * 這纔是一個真正的泛型方法。 * 首先在public與返回值之間的<T>必不可少,這代表這是一個泛型方法,而且聲明瞭一個泛型T * 這個T能夠出如今這個泛型方法的任意位置. * 泛型的數量也能夠爲任意多個 * 如:public <T,K> K showKeyName(Generic<T> container){ * ... * } */ public <T> T showKeyName(Generic<T> container){ System.out.println("container key :" + container.getKey()); //固然這個例子舉的不太合適,只是爲了說明泛型方法的特性。 T test = container.getKey(); return test; } //這也不是一個泛型方法,這就是一個普通的方法,只是使用了Generic<Number>這個泛型類作形參而已。 public void showKeyValue1(Generic<Number> obj){ Log.d("泛型測試","key value is " + obj.getKey()); } //這也不是一個泛型方法,這也是一個普通的方法,只不過使用了泛型通配符? //同時這也印證了泛型通配符章節所描述的,?是一種類型實參,能夠看作爲Number等全部類的父類 public void showKeyValue2(Generic<?> obj){ Log.d("泛型測試","key value is " + obj.getKey()); } /** * 這個方法是有問題的,編譯器會爲咱們提示錯誤信息:"UnKnown class 'E' " * 雖然咱們聲明瞭<T>,也代表了這是一個能夠處理泛型的類型的泛型方法。 * 可是隻聲明瞭泛型類型T,並未聲明泛型類型E,所以編譯器並不知道該如何處理E這個類型。 public <T> T showKeyName(Generic<E> container){ ... } */ /** * 這個方法也是有問題的,編譯器會爲咱們提示錯誤信息:"UnKnown class 'T' " * 對於編譯器來講T這個類型並未項目中聲明過,所以編譯也不知道該如何編譯這個類。 * 因此這也不是一個正確的泛型方法聲明。 public void showkey(T genericObj){ } */ public static void main(String[] args) { } }
固然這並非泛型方法的所有,泛型方法能夠出現雜任何地方和任何場景中使用。可是有一種狀況是很是特殊的,當泛型方法出如今泛型類中時,咱們再經過一個例子看一下dom
public class GenericFruit { class Fruit{ @Override public String toString() { return "fruit"; } } class Apple extends Fruit{ @Override public String toString() { return "apple"; } } class Person{ @Override public String toString() { return "Person"; } } class GenerateTest<T>{ public void show_1(T t){ System.out.println(t.toString()); } //在泛型類中聲明瞭一個泛型方法,使用泛型E,這種泛型E能夠爲任意類型。能夠類型與T相同,也能夠不一樣。 //因爲泛型方法在聲明的時候會聲明泛型<E>,所以即便在泛型類中並未聲明泛型,編譯器也可以正確識別泛型方法中識別的泛型。 public <E> void show_3(E t){ System.out.println(t.toString()); } //在泛型類中聲明瞭一個泛型方法,使用泛型T,注意這個T是一種全新的類型,能夠與泛型類中聲明的T不是同一種類型。 public <T> void show_2(T t){ System.out.println(t.toString()); } } public static void main(String[] args) { Apple apple = new Apple(); Person person = new Person(); GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>(); //apple是Fruit的子類,因此這裏能夠 generateTest.show_1(apple); //編譯器會報錯,由於泛型類型實參指定的是Fruit,而傳入的實參類是Person //generateTest.show_1(person); //使用這兩個方法均可以成功 generateTest.show_2(apple); generateTest.show_2(person); //使用這兩個方法也均可以成功 generateTest.show_3(apple); generateTest.show_3(person); } }
再看一個泛型方法和可變參數的例子(這裏的 T 能夠同時傳入不一樣類型):ide
public <T> void printMsg( T... args){ for(T t : args){ Log.d("泛型測試","t is " + t); } } printMsg("111",222,"aaaa","2323.4",55.55);
靜態方法有一種狀況須要注意一下,那就是在類中的靜態方法使用泛型:靜態方法沒法訪問類上定義的泛型;若是靜態方法操做的引用數據類型不肯定的時候,必需要將泛型定義在方法上。函數
即:若是靜態方法要使用泛型的話,必須將靜態方法也定義成泛型方法 。測試
public class StaticGenerator<T> { .... .... /** * 若是在類中定義使用泛型的靜態方法,須要添加額外的泛型聲明(將這個方法定義成泛型方法) * 即便靜態方法要使用泛型類中已經聲明過的泛型也不能夠。 * 如:public static void show(T t){..},此時編譯器會提示錯誤信息: "StaticGenerator cannot be refrenced from static context" */ public static <T> void show(T t){ } }
泛型方法能使方法獨立於類而產生變化,如下是一個基本的指導原則:
不管什麼時候,若是你能作到,你就該儘可能使用泛型方法。也就是說,若是使用泛型方法將整個類泛型化,那麼就應該使用泛型方法。另外對於一個static的方法,沒法訪問泛型類的泛型參數。因此若是static方法要使用泛型能力,就必須使其成爲泛型方法。ui
泛型類的聲明和非泛型類的聲明相似,除了在類名後面添加了類型參數聲明部分。
和泛型方法同樣,泛型類的類型參數聲明部分也包含一個或多個類型參數,參數間用逗號隔開。一個泛型參數,也被稱爲一個類型變量,是用於指定一個泛型類型名稱的標識符。由於他們接受一個或多個參數,這些類被稱爲參數化的類或參數化的類型。
泛型接口與泛型類的定義及使用基本相同。泛型接口常被用在各類類的生產器中,能夠看一個例子:
//定義一個泛型接口 public interface Generator<T> { public T next(); }
當實現泛型接口的類,未傳入泛型實參時:
/** * 未傳入泛型實參時,與泛型類的定義相同,在聲明類的時候,需將泛型的聲明也一塊兒加到類中 * 即:class FruitGenerator<T> implements Generator<T>{ * 若是不聲明泛型,如:class FruitGenerator implements Generator<T>,編譯器會報錯:"Unknown class" */ class FruitGenerator<T> implements Generator<T>{ @Override public T next() { return null; } }
當實現泛型接口的類,傳入泛型實參時:
/** * 傳入泛型實參時: * 定義一個生產器實現這個接口,雖然咱們只建立了一個泛型接口Generator<T> * 可是咱們能夠爲T傳入無數個實參,造成無數種類型的Generator接口。 * 在實現類實現泛型接口時,如已將泛型類型傳入實參類型,則全部使用泛型的地方都要替換成傳入的實參類型 * 即:Generator<T>,public T next();中的的T都要替換成傳入的String類型。 */ public class FruitGenerator implements Generator<String> { private String[] fruits = new String[]{"Apple", "Banana", "Pear"}; @Override public String next() { Random rand = new Random(); return fruits[rand.nextInt(3)]; } }
在使用泛型的時候,咱們還能夠爲傳入的泛型類型實參進行上下邊界的限制,如:類型實參只准傳入某種類型的父類或某種類型的子類。
爲泛型添加上邊界,即傳入的類型實參必須是指定類型的子類型
public void showKeyValue1(Generic<? extends Number> obj){ Log.d("泛型測試","key value is " + obj.getKey()); } Generic<String> generic1 = new Generic<String>("11111"); Generic<Integer> generic2 = new Generic<Integer>(2222); Generic<Float> generic3 = new Generic<Float>(2.4f); Generic<Double> generic4 = new Generic<Double>(2.56); //這一行代碼編譯器會提示錯誤,由於String類型並非Number類型的子類 //showKeyValue1(generic1); showKeyValue1(generic2); showKeyValue1(generic3); showKeyValue1(generic4);
若是咱們把泛型類的定義也改一下:
public class Generic<T extends Number>{ private T key; public Generic(T key) { this.key = key; } public T getKey(){ return key; } } //這一行代碼也會報錯,由於String不是Number的子類 Generic<String> generic1 = new Generic<String>("11111");
再來一個泛型方法的例子:
//在泛型方法中添加上下邊界限制的時候,必須在權限聲明與返回值之間的<T>上添加上下邊界,即在泛型聲明的時候添加//public <T> T showKeyName(Generic<T extends Number> container),編譯器會報錯:"Unexpected bound"public <T extends Number> T showKeyName(Generic<T> container){ System.out.println("container key :" + container.getKey()); T test = container.getKey(); return test; }
經過上面的兩個例子能夠看出:泛型的上下邊界添加,必須與泛型的聲明在一塊兒 。
本身設計一個泛型的獲取數組最小值的函數.而且這個方法只能接受Number的子類而且實現了Comparable接口。
//注意:Number並無實現Comparable private static <T extends Number & Comparable<? super T>> T min(T[] values) { if (values == null || values.length == 0) return null; T min = values[0]; for (int i = 1; i < values.length; i++) { if (min.compareTo(values[i]) > 0) min = values[i]; } return min; }
測試:
int minInteger = min(new Integer[]{1, 2, 3}); //result:1double minDouble = min(new Double[]{1.2, 2.2, -1d}); //result:-1d String typeError = min(new String[]{"1","3"});//報錯