java基礎學習筆記之泛型_java

泛型

將集合中的元素限定為一個特定的類型。

術語

1. ArrayList<E> -- 泛型型別
2. ArrayList -- 原始類型
3. E -- 型別參數
4. <> -- 讀作"typeof"
5. ArrayList<Integer> -- 參數化類別型
6. Integer -- 實際型別參數
   

幾點注意：

參數化型別和原始類型相互相容

ArrayList collection1 = new ArrayList<Integer>();//通過,無warningArrayList<Integer> collection2 = new ArrayList();//通過,有warning

參數化型別不考慮型別參數的繼承關係

ArrayList<String> collection3 = new ArrayList<Object>();//編譯不通過ArrayList<Object> collection4 = new ArrayList<String>();//編譯不通過

但是

ArrayList collection5 = new ArrayList<Integer>();ArrayList<String> collection6 = collection5;//編譯通過

"?"萬用字元

"?"表示任意類型，使用"?"萬用字元可以引用各種參數化類別型，可以調用與參數化無關的方法(如size()方法)，不能調用與參數化有關的方法(如add()方法)

萬用字元的擴充

限定萬用字元的上邊界

ArrayList<? extends Number > collection1= new ArrayList<Integer >();//編譯通過ArrayList<? extends Number > collection2= new ArrayList<String>();//編譯不通過

限定萬用字元的下邊界

ArrayList<? super Integer > collection3= new ArrayList<Number >();//編譯通過ArrayList<? super Integer > collection4= new ArrayList<String>();//編譯不通過

自訂泛型方法

C++模板函數

template <class T> T add(T x, T y){  return (T)(x+y);}

而java的泛型基本上完全在編譯器中實現，用於編譯器執行類型檢查和類型判斷，然後產生普通的非泛型的位元組碼，這種實現技術為“擦除”(erasure)。

"擦除"執行個體

泛型是提供給javac編譯器使用的，限定集合的輸入類型，編譯器編譯帶類型說明的集合時會去掉“類型”資訊。

public class GenericTest {  public static void main(String[] args) {    new GenericTest().testType();  }  public void testType(){    ArrayList<Integer> collection1 = new ArrayList<Integer>();    ArrayList<String> collection2= new ArrayList<String>();    System.out.println(collection1.getClass()==collection2.getClass());    //兩者class類型一樣,即位元組碼一致    System.out.println(collection2.getClass().getName());    //class均為java.util.ArrayList,並無實際型別參數資訊  }}

輸出

true
java.util.ArrayList
使用反射可跳過編譯器，往某個泛型集合加入其它類型資料。

只有參考型別才能作為泛型方法的實際參數 例子：

public class GenericTest {  public static void main(String[] args) {    swap(new String[]{"111","222"},0,1);//編譯通過    //swap(new int[]{1,2},0,1);    //編譯不通過,因為int不是參考型別    swap(new Integer[]{1,2},0,1);//編譯通過  }  /*交換數組a 的第i個和第j個元素*/  public static <T> void swap(T[]a,int i,int j){    T temp = a[i];    a[i] = a[j];    a[j] = temp;  }}

但注意基本類型有時可以作為實參，因為有自動裝箱和拆箱。 例子(編譯通過了)：

public class GenericTest {  public static void main(String[] args) {    new GenericTest().testType();    int a = biggerOne(3,5);    //int 和 double,取交為Number    Number b = biggerOne(3,5.5);    //String和int 取交為Object    Object c = biggerOne("1",2);  }  //從x,y中返回y  public static <T> T biggerOne(T x,T y){    return y;  }}

同時，該例還表明，當實參不一致時，T取交集，即第一個共同的父類。 另外，如果用Number b = biggerOne(3,5.5);改為String c = biggerOne(3,5.5);則編譯報錯:

Error:(17, 29) java: 不相容的類型: 推斷類型不符合上限
    推斷: java.lang.Number&java.lang.Comparable<? extends java.lang.Number&java.lang.Comparable<?>>
    上限: java.lang.String,java.lang.Object
但是有一點沒搞清楚，我在IDEA裡面單步調試，發現結果如下圖： 泛型調試截圖-1 不知道b為什麼是Double類型的（但直接Double b接收傳回值會編譯報錯）。不知道跟IDE有沒有關係，是不是IDE在debug時會顯示這個對象最精確的類型？

型別參數的類型推斷

編譯器判斷泛型方法的實際型別參數的過程稱為類型推斷。

當某個類型變數只在整個參數列表的所有參數和傳回值中的一處被應用了，那麼根據調用方法時該處的實際應用類型來確定。即直接根據調用方法時傳遞的參數類型或傳回值來決定泛型參數的類型。 例如：

swap(new String[3],1,2) -> static <E> void swap(E[]a,int i,int j)

當某個類型變數在整個參數列表的所有參數和傳回值中的多處被應用了，如果調用方法時這麼多處的實際應用類型都 對應同一種類型，則泛型參數的類型就是該類型。 例如：

add(3,5) -> static <T> T add(T a,T b)

當某個類型變數在整個參數列表的所有參數和傳回值中的*多處被應用了，如果調用方法時這麼多處的實際應用類型 對應不同的類型,且沒有傳回值，則取多個參數中的最大交集類型，即第一個公用父類。 例如：

fill(new Integer[3],3.5) -> static <T> void fill(T a[],T v)

該例子實際對應的類型就是Number,編譯通過，運行出問題。

當某個類型變數在整個參數列表的所有參數和傳回值中的多處被應用了，如果調用方法時這麼多處的實際應用類型對應不同的類型,且使用有傳回值，則優先考慮傳回值的類型
例如：

int x = add(3,3.5) -> static <T> T add(T a,T b)

上例編譯報錯,x類型改為float也報錯，改為Number成功。

參數類型的類型推斷具有傳遞性
例子：

copy(new Integer[5],new String[5]) -> static <T> void copy(T []a,T []b)

該例推斷實際參數類型為Object,編譯通過.

copy(new ArrayList<String>,new Integer[5]) -> static <T> void copy(Collection<T>a,T[]b)

該例則根據參數化的ArrayList類執行個體將類型變數直接確定為String類型，編譯報錯。

自訂泛型類

例子

public class GenericDao<T>{  public void add(T x){  }  public T findById(int id){    return null;  }  public void delete(T obj){  }  public void delete(int id){  }  public void update(T obj){  }  public T findByUserName(String name){    return null;  }  public <T> Set<T> findByConditions(String where){    return null;  }}

注意：當一個變數被聲明為泛型時，只能被執行個體變數和方法調用(還有內嵌類型)，而不能被靜態變數和靜態方法調用。因為靜態成員是被所參數化類別所共用的，所以靜態成員不應該有類層級的型別參數。

泛型方法和泛型類的比較

例子：

public class A<T>(){  //泛型類的成員方法，該T受A後面的T的限制  public T memberFunc(){    return null;  }  //泛型方法，這裡的T和和類A的T是不同的  public static <T> T genericFunc(T a){    return null;  }  public static void main(String[] args) {    //編譯不通過    //Integer i = A<String>().findByUserName("s");    //編譯通過    Set<Integer> set= A<String>().findByConditions("s");  }}

這裡Integer i = A<String>().findByUserName("s");會編譯報錯：

Error:(35, 61) java: 不相容的類型: java.lang.String無法轉換為java.lang.Integer

由這個例子可知，泛型方法的T和和類A的T是不同的。

泛型和反射

通過反射獲得泛型的實際型別參數

把泛型變數當成方法的參數，利用Method類的getGenericParameterTypes方法來擷取泛型的實際型別參數 例子：

public class GenericTest {  public static void main(String[] args) throws Exception {    getParamType();  }   /*利用反射擷取方法參數的實際參數類型*/  public static void getParamType() throws NoSuchMethodException{    Method method = GenericTest.class.getMethod("applyMap",Map.class);    //擷取方法的泛型參數的類型    Type[] types = method.getGenericParameterTypes();    System.out.println(types[0]);    //參數化類別型    ParameterizedType pType = (ParameterizedType)types[0];    //原始類型    System.out.println(pType.getRawType());    //實際型別參數    System.out.println(pType.getActualTypeArguments()[0]);    System.out.println(pType.getActualTypeArguments()[1]);  }  /*供測試參數類型的方法*/  public static void applyMap(Map<Integer,String> map){  }}

輸出結果：

java.util.Map<java.lang.Integer, java.lang.String>interface java.util.Mapclass java.lang.Integerclass java.lang.String