簡單談談Java泛型-有解無憂

| 前言

Java 泛型（generics）是 JDK 5 中引入的一個新特性, 泛型提供了編譯時型別安全檢測機制，該機制允許開發者在編譯時檢測到非法的型別，

泛型的本質是引數化型別，也就是說所操作的資料型別被指定為一個引數，

| 泛型帶來的好處

在沒有泛型的情況的下，通過對型別 Object 的參考來實作引數的“任意化”，“任意化”帶來的缺點是要做顯式的強制型別轉換，而這種轉換是要求開發者對實際引數型別可以預知的情況下進行的，對于強制型別轉換錯誤的情況，編譯器可能不提示錯誤，在運行的時候才出現例外，這是本身就是一個安全隱患，

那么泛型的好處就是在編譯的時候能夠檢查型別安全，并且所有的強制轉換都是自動和隱式的，

public class GlmapperGeneric<T> {
  private T t;
    public void set(T t) { this.t = t; }
    public T get() { return t; }

    public static void main(String[] args) {
        // do nothing
    }

  /**
    * 不指定型別
    */
  public void noSpecifyType(){
    GlmapperGeneric glmapperGeneric = new GlmapperGeneric();
    glmapperGeneric.set("test");
    // 需要強制型別轉換
    String test = (String) glmapperGeneric.get();
    System.out.println(test);
  }

  /**
    * 指定型別
    */
  public void specifyType(){
    GlmapperGeneric<String> glmapperGeneric = new GlmapperGeneric();
    glmapperGeneric.set("test");
    // 不需要強制型別轉換
    String test = glmapperGeneric.get();
    System.out.println(test);
  }
}

上面這段代碼中的 specifyType 方法中省去了強制轉換，可以在編譯時候檢查型別安全，可以用在類，方法，介面上，

| 泛型中通配符

我們在定義泛型類，泛型方法，泛型介面的時候經常會碰見很多不同的通配符，比如 T，E，K，V 等等，這些通配符又都是什么意思呢？

常用的 T，E，K，V，？

本質上這些個都是通配符，沒啥區別，只不過是編碼時的一種約定俗成的東西，比如上述代碼中的 T ，我們可以換成 A-Z 之間的任何一個字母都可以，并不會影響程式的正常運行，但是如果換成其他的字母代替 T ，在可讀性上可能會弱一些，通常情況下，T，E，K，V，？是這樣約定的：

？表示不確定的 java 型別
T (type) 表示具體的一個java型別
K V (key value) 分別代表java鍵值中的Key Value
E (element) 代表Element

？無界通配符

先從一個小例子看起，

我有一個父類 Animal 和幾個子類，如狗、貓等，現在我需要一個動物的串列，我的第一個想法是像這樣的：

1 List<Animal> listAnimals

但是老板的想法確實這樣的：

1 List<? extends Animal> listAnimals

為什么要使用通配符而不是簡單的泛型呢？通配符其實在宣告區域變數時是沒有什么意義的，但是當你為一個方法宣告一個引數時，它是非常重要的，

 1 static int countLegs (List<? extends Animal > animals ) {
 2     int retVal = 0;
 3     for ( Animal animal : animals )
 4     {
 5         retVal += animal.countLegs();
 6     }
 7     return retVal;
 8 }
 9 
10 static int countLegs1 (List< Animal > animals ){
11     int retVal = 0;
12     for ( Animal animal : animals )
13     {
14         retVal += animal.countLegs();
15     }
16     return retVal;
17 }
18 
19 public static void main(String[] args) {
20     List<Dog> dogs = new ArrayList<>();
21   // 不會報錯
22     countLegs( dogs );
23  // 報錯
24     countLegs1(dogs);
25 }

當呼叫 countLegs1 時，就會飄紅，提示的錯誤資訊如下：

所以，對于不確定或者不關心實際要操作的型別，可以使用無限制通配符（尖括號里一個問號，即 <?> ），表示可以持有任何型別，像 countLegs 方法中，限定了上界，但是不關心具體型別是什么，所以對于傳入的 Animal 的所有子類都可以支持，并且不會報錯，而 countLegs1 就不行，

上界通配符 < ? extends E>

上屆：用 extends 關鍵字宣告，表示引數化的型別可能是所指定的型別，或者是此型別的子類，

在型別引數中使用 extends 表示這個泛型中的引數必須是 E 或者 E 的子類，這樣有兩個好處：

如果傳入的型別不是 E 或者 E 的子類，編譯不成功
泛型中可以使用 E 的方法，要不然還得強轉成 E 才能使用

1 private <K extends A, E extends B> E test(K arg1, E arg2){
2     E result = arg2;
3     arg2.compareTo(arg1);
4     //.....
5     return result;
6 }

型別引數串列中如果有多個型別引數上限，用逗號分開

下界通配符 < ? super E>

下界: 用 super 進行宣告，表示引數化的型別可能是所指定的型別，或者是此型別的父型別，直至 Object

在型別引數中使用 super 表示這個泛型中的引數必須是 E 或者 E 的父類，

 1 private <T> void test(List<? super T> dst, List<T> src){
 2     for (T t : src) {
 3         dst.add(t);
 4     }
 5 }
 6 
 7 public static void main(String[] args) {
 8     List<Dog> dogs = new ArrayList<>();
 9     List<Animal> animals = new ArrayList<>();
10     new Test3().test(animals,dogs);
11 }
12 // Dog 是 Animal 的子類
13 class Dog extends Animal {
14 
15 }

dst 型別 “大于等于” src 的型別，這里的“大于等于”是指 dst 表示的范圍比 src 要大，因此裝得下 dst 的容器也就能裝 src ，

？和 T 的區別

？和 T 都表示不確定的型別，區別在于我們可以對 T 進行操作，但是對？不行，比如如下這種：

1 // 可以
2 T t = operate();
3 
4 // 不可以
5 ？car = operate();

簡單總結下：

T 是一個確定的型別，通常用于泛型類和泛型方法的定義，？是一個不確定的型別，通常用于泛型方法的呼叫代碼和形參，不能用于定義類和泛型方法，

區別1：通過 T 來確保泛型引數的一致性

1 // 通過 T 來 確保 泛型引數的一致性
2 public <T extends Number> void
3 test(List<T> dest, List<T> src)
4 
5 //通配符是 不確定的，所以這個方法不能保證兩個 List 具有相同的元素型別
6 public void
7 test(List<? extends Number> dest, List<? extends Number> src)

像下面的代碼中，約定的 T 是 Number 的子類才可以，但是申明時是用的 String ，所以就會飄紅報錯，

不能保證兩個 List 具有相同的元素型別的情況

1 GlmapperGeneric<String> glmapperGeneric = new GlmapperGeneric<>();
2 List<String> dest = new ArrayList<>();
3 List<Number> src = https://www.cnblogs.com/uhan/p/new ArrayList<>();
4 glmapperGeneric.testNon(dest,src);

上面的代碼在編譯器并不會報錯，但是當進入到 testNon 方法內部操作時（比如賦值），對于 dest 和 src 而言，就還是需要進行型別轉換，

區別2：型別引數可以多重限定而通配符不行

使用 & 符號設定多重邊界（Multi Bounds)，指定泛型型別 T 必須是 MultiLimitInterfaceA 和 MultiLimitInterfaceB 的共有子型別，此時變數 t 就具有了所有限定的方法和屬性，對于通配符來說，因為它不是一個確定的型別，所以不能進行多重限定，

區別3：通配符可以使用超類限定而型別引數不行

型別引數 T 只具有一種型別限定方式：

T extends A

但是通配符 ? 可以進行兩種限定：

? extends A
? super A

`| Class<T>`和 `Class<?>`區別

前面介紹了？和 T 的區別，那么對于，Class<T>和 <Class<?>又有什么區別呢？Class<T>和 Class<?>

最常見的是在反射場景下的使用，這里以用一段發射的代碼來說明下，

1 // 通過反射的方式生成  multiLimit
2 // 物件，這里比較明顯的是，我們需要使用強制型別轉換
3 MultiLimit multiLimit = (MultiLimit)
4 Class.forName("com.glmapper.bridge.boot.generic.MultiLimit").newInstance();

對于上述代碼，在運行期，如果反射的型別不是 MultiLimit 類，那么一定會報 java.lang.ClassCastException 錯誤，

對于這種情況，則可以使用下面的代碼來代替，使得在在編譯期就能直接檢查到型別的問題：

Class<T>在實體化的時候，T 要替換成具體類，Class<?>它是個通配泛型，? 可以代表任何型別，所以主要用于宣告時的限制情況，比如，我們可以這樣做申明：

1 // 可以
2 public Class<?> clazz;
3 // 不可以，因為 T 需要指定型別
4 public Class<T> clazzT;

所以當不知道定宣告什么型別的 Class 的時候可以定義一個Class<?>，

那如果也想 public Class<T> clazzT;這樣的話，就必須讓當前的類也指定 T ，

1 public class Test3<T> {
2     public Class<?> clazz;
3     // 不會報錯
4     public Class<T> clazzT;

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/327742.html

標籤：Java

上一篇：1萬字長文高速你千萬級并發架構下如何提高資料庫存盤性能

下一篇：微服務怎么限流？演算法＋框架＋實戰！

簡單談談Java泛型