四、泛型

1. 請不要再新代碼中使用原生態類型

泛型類/接口：聲明中具有一個或者多個類型參數的類/接口。

每個泛型都定義一個原生態類型，即不帶任何實際類型參數的泛型名稱。如與List<E>相對應的原生態類型就是List。原生態類型沒有泛型在安全性和表述性方面的優勢，它的存在僅是爲了兼容引入泛型之前的遺留代碼，不應在新代碼中繼續使用。

//使用原生態類型
private final List stamps = new ArrayList();
stamps.add( new Stamp() );
stamps.add( new Coin() ); //可以正常添加
Stamp stamp = (Stamp)stamps.get(1); //運行時錯誤，拋出ClassCastException。

//使用泛型
private final List<Stamp> stamps = new ArrayList<Stamp>();
stamps.add( new Stamp() );
stamps.add( new Coin() ); //提示錯誤，無法通過編譯
Stamp stamp = stamps.get(0); //使用時無需進行手工轉換

由上述代碼可以看出，使用泛型的兩個好處：

由編譯器確保插入正確的元素類型
從集合獲取元素時不再需要手工轉換了

如果要使用泛型，但不確定或不關心實際的類型參數，可以使用一個?代替，稱作無限制的通配符類型，如泛型Set<E>的無限制通配符類型爲Set<?>，讀作某個類型的集合。通配符類型是安全的，原生態類型不安全。

不在新代碼中使用原生態類型這條規則有兩種例外情況：
（1）在類文字中必須使用原生態類型

//正確的用法
List.class
String[].class
int.class

//錯誤的用法
List<String.class>
List<?>.class

（2）在instanceof操作符中必須使用原生態類型

if (o instanceof Set) {
    Set<?> m = (Set<?>)o;
}

上述兩種例外都是源於泛型信息可以在運行時被擦除。

2. 消除非受檢警告

用泛型編程時，會遇到很多編譯器警告：

非受檢強制轉換警告
非受檢方法調用警告
非受檢普通數組創建警告
非受檢轉換警告

要儘可能地消除每一個非受檢警告，這可以確保代碼是類型安全的，意味着代碼在運行時不會出現ClassCastException異常。

如果無法消除警告，同時可以證明引起警告的代碼是類型安全的。只有在這種條件下纔可以使用 @SuppressWarnings("unchecked") 註解來禁止這種警告。

SuppressWarnings註解可以用在任何粒度的級別中，從單獨的局部變量聲明到整個類的定義都可以。應該始終在儘可能小的範圍中使用SuppressWarnings註解，永遠不要在整個類上使用SuppressWarnings，因爲這麼做可能會掩蓋重要的警告信息。

每當使用@SuppressWarnings("unchecked")註解時，都要添加一條註釋，說明爲什麼這麼做是安全的。這樣做可以幫助他人理解代碼，更重要的是，可以儘量減少其他人修改代碼後導致計算不安全的概率。

3. 列表優先於數組

數組與泛型相比，有兩個重要的不同點：
（1）數組是協變的
協變指的是如果Sub爲Super的子類型，那麼數組類型Sub[]就是Super[]的子類型；
泛型是不可變的，對於任意兩個不同的類型Type1和Type2，List<Type1>既不是List<Type2>的子類型，也不是List<Type2>的超類型。
（2）數組是具體化的
數組在運行時才知道並檢查它們的元素類型約束；
泛型則通過類型擦除來實現，它在編譯時強化它們的類型信息，在運行時丟棄（或擦除）它們的元素類型信息。

由於數組的協變性和具體化，它是有缺陷的：

//數組具有協變性，Object是Long的父類，聲明合法
Object[] objectArray = new Long[1];
//Long[] 退化爲Object[]，此處賦值也是合法的
objectArray[0] = "I don't fit in";

上述代碼可以通過編譯，但運行時卻拋出ArrayStoreException。
改爲列表後，則無法通過編譯時的類型檢查：

//無法通過編譯，List<Object>和List<Long>是不同的類型
List<Object> ol = new ArrayList<Long>();
ol.add("I don't fit in");

因爲數組和泛型之間有着根本性的區別，數組和泛型不能很好地混合使用。如下列類型的表達式都是非法的：new List<E>[]、new List<String>[]、new E[]。
創建泛型數組是非法的，是因爲泛型數組不是類型安全的。如下代碼所示：

List<String>[] strLists = new List<String>[1]; //假設此處合法
List<Integer> intList = Arrays.asList(42);
Object[] objects = strLists; //數組是協變的，此處合法
objects[0] = intList;
String s = strLists[0].get(0); //運行時ClassCastException異常

當得到泛型數組創建錯誤時，最好的解決辦法通常是優先使用集合類型List<E>，而不是數組類型E[]。這樣可能會損失一些性能或簡潔性，但換回的卻是更高的類型安全性和互用性。

4.優先考慮泛型

編寫自己的泛型相對比較困難，但很值得花時間去學習如何編寫。
下面以一個Stack類爲例來說明：

public class Stack {
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    
    public Stack() {
        elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }
    
    public void push(Object e) {
        ensureCapacity();
        elements[size++] = e;
    }
    
    public Object pop() {
        if (size == 0) {
            throw new EmptyStackException();
        }
        Object result = elements[--size];
        elements[size] = null;
        return result;
    }
    
    public boolean isEmpty() {
        return size == 0;
    }
    
    private void ensureCapacity() {
        if (elements.length == size) {
            elements = Arrays.copyOf(elements, 2 * DEFAULT_INITIAL_CAPACITY + 1);
        }
    }
}

上述Stack類的實現，主要問題有如下兩點：
（1）push操作無法保證類型安全

//可以向stack中放入任意類型
Stack stack = new Stack();
stack.push("stack");
stack.put(new Integer(100));

（2）pop操作獲得元素需要外部手工進行類型轉換，且可能會產生ClassCastException異常。

String str = (String)stack.pop();

將上述Stack類進行泛型化，主要步驟爲：

給它的聲明添加一個或者多個類型參數
用相應的類型參數替換所有的Object類型，嘗試編譯

public class Stack<E> {
    private E[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    
    public Stack() {
        //此處提示錯誤，無法通過編譯，因爲無法創建泛型數組
        elements = new E[DEFAULT_INITIAL_CAPACITY];
    }
    
    public void push(E e) {
        ensureCapacity();
        elements[size++] = e;
    }
    
    public E pop() {
        if (size == 0) {
            throw new EmptyStackException();
        }
        E result = elements[--size];
        elements[size] = null;
        return result;
    }
    
    public boolean isEmpty() {
        return size == 0;
    }
    
    private void ensureCapacity() {
        if (elements.length == size) {
            elements = Arrays.copyOf(elements, 2 * DEFAULT_INITIAL_CAPACITY + 1);
        }
    }
}

消除泛型數組的方法有兩種：
（1）直接繞過創建泛型數組，創建一個Object數組

//用法合法，但整體上而言不是類型安全的
elements = (E[])Object[DEFAULT_INITIAL_CAPACITY];

（2）將域的類型從E[]改爲Object[]（推薦使用此種方法）

public class Stack<E> {
    private Object[] elements;
    ...

    public Stack() {
        elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }

    public E pop() {
        if (size == 0) {
            throw new EmptyStackException();
        }
        E result = (E) elements[--size];
        elements[size] = null;
        return result;
    }
}

5. 優先考慮泛型方法

靜態工具方法通常比較適合泛型化。
編寫泛型方法與編寫泛型類相似，如下述代碼：

public static Set union(Set s1, Set s2) {
    Set result = new HashSet(s1);
    result.addAll(s2);
    return result;
}

上述union方法並不是類型安全的，將其泛型化的代碼如下：

public static <E> Set<E> union(Set<E> s1, Set<E> s2) {
    Set<E> result = new HashSet<E>(s1);
    result.addAll(s2);
    return result;
}

泛型後的union方法不僅適用性更強，也是類型安全的，它確保了待合併集合的類型一致性，外部使用也無需進行手工強制轉換。

6. 利用有限制通配符來提升API的靈活性

泛型不具備協變性，但有時，我們又需要使用協變帶來的靈活性，於是Java提供了有限制的通配符類型這種特殊的參數化類型：

GenericType<? extends E>：子類型通配符，通配符?表示E的某個子類型
GenericType<? super E>：超類型通配符，通配符?表示E的某個超類型

考慮Stack的公共API：

public class Stack<E> {
    public Stack();
    public void push(E e);
    public E pop();
    public boolean isEmpty();
}

假如我們想增加一個方法，讓它按順序把一系列元素添加到Stack中，嘗試如下：

public void pushAll(Iterable<E> src) {
    for (E e : src) {
        push(e);
    }
}

如果src中的元素類型與Stack的泛型參數類型完全匹配，是完全沒有問題的。但考慮這樣一種情形：有一個Stack<Number>，且調用了push(int val)，從邏輯上講，下面的實現應該是可以的：

Stack<Number> stack = new Stack<Number>();
Iterable<Integer> integers = ...;
stack.pushAll(integers);

實際情況是上述辦法並不可行，會導致編譯錯誤。
顯然，我們的目的是想將E的某個子類型也放入Stack中（Integer是Number的子類），可以利用子類型通配符來做有限制的規定：

public void pushAll(Iterable<? extends E> src) {
    for (E e : src) {
        push(e);
    }
}

假設現在需要編寫一個popAll方法，使之與pushAll方法相呼應，popAll方法從Stack中彈出每個元素，並將這些元素添加到指定的集合中，嘗試如下：

public void popAll(Collection<E> dst) {
    while (!isEmpty()) {
        dst.add(pop());
    }
}

如果dst的元素類型與Stack完全匹配，上述實現是沒有問題的。但考慮這樣一種情形：有一個Stack<Number>和Collection<Object>，從邏輯上講，下面的實現應該是可以的：

Stack<Number> numStack = new Stack<Number>();
Collection<Object> coll = ...;
numStack.popAll(coll);

實際情況是上述辦法並不可行，會導致編譯錯誤。Collection<Object>並不是Collection<Number>的超類型。
我們的目的是爲了將類型爲E的元素加入到目標泛型集合中，且目標集合的泛型參數類型只要是類型E的父類型即可（Object是Number的父類），Java提供了父類型通配符來實現這種需求：

//此處的限定是：通配符類型是泛型參數類型的父類即可
public void popAll(Collection<? super E> dst) {
    while(!isEmpty()) {
        dst.add(pop());
    }
}

爲了便於記住要使用哪種通配符，引入下面的助記符：
PECS表示producer-extends，consumer-super。
如果參數化類型表示一個T生產者，就使用<? extends T>；如果它表示一個T消費者，就使用<? super T>。在Stack示例中，pushAll的src參數產生E實例供Stack使用，因此src相應的類型爲Iterable<? extends E>；popAll的dst參數通過Stack消費E實例，因此dst相應的類型爲Collection<? super E>。
PECS助記符突出了使用通配符類型的基本原則。

7. 優先考慮類型安全的異構容器

Java泛型也提供了另一種用法：將鍵（key）進行參數化而不是將容器參數化，然後將參數化的鍵提交給容器，來插入或者獲取值，用泛型系統來確保值的類型與它的鍵相符。

類Class在Java1.5中被泛化了，類的類型從字面上看不再只是簡單的Class，而是Class<T>，意味着String.class是屬於Class<String>類型，Integer.class屬於Class<Integer>類型。
當一個類的字面文字被用在方法中，來傳達編譯時和運行時的類型信息時，被稱作type token。

假如需要設計一個Favorites類，它允許其客戶端從任意數量的其他類中，保存並獲得一個“最喜愛”的實例，代碼如下：

public class Favorites {
    private Map<Class<?>, Object> favorities = new HashMap<Class<?>, Object>();

    public <T> void putFavorite(Class<T> type, T instance) {
        if (type == null) {
            throw new NullPointerException("Type is null");
        }
        favorities.put(type, instance);
    }

    public <T> T getFavorite(Class<T> type) {
        return type.cast(favorities.get(type));
    }

    public static void main(String[] args) {
        Favorites f = new Favorites();
        f.putFavorite(String.class, "Java");
        f.putFavorite(Integer.class, 0xcafebabe);
        f.putFavorite(Class.class, Favorites.class);

        String fString = f.getFavorite(String.class);
        int fInteger = f.getFavorite(Integer.class);
        Class<?> fClass = f.getFavorite(Class.class);

        System.out.printf("%s %x %s%n", fString, fInteger, fClass.getSimpleName());
    }
}
//代碼打印結果爲：Java cafebabe Favorites

Favorites實例是類型安全的：當你向它請求String的時候，它不會返回一個Integer。同時它也是異構的：不像普通的map，它的所有鍵都是不同類型的。
像Favorites這種類被稱爲類型安全的異構容器。對於這種類型安全的異構容器，可以用Class對象作爲鍵。
以這種方式使用的Class對象被稱作類型令牌。Favorites使用的類型令牌是無限制的，還可以利用有限制類型參數或有限制通配符來限制可以表示的類型：

    public <T extends Annotation> T getAnnotation(Class<T> annotationType);

    Annotation getAnnotation(AnnotatedElement element, String annotationTypeName) {
        Class<?> annotationType = null;
        try {
            annotationType = Class.forName(annotationTypeName);
        } catch (Exception e) {
            throw new IllegalArgumentException();
        }
        return element.getAnnotation(annotationType.asSubclass(Annotation.class));
    }

Fighting_初心

發佈了66 篇原創文章 · 獲贊 66 · 訪問量 2萬+

私信關注

Effective Java（四）

四、泛型

1. 請不要再新代碼中使用原生態類型

2. 消除非受檢警告

3. 列表優先於數組

4.優先考慮泛型

5. 優先考慮泛型方法

6. 利用有限制通配符來提升API的靈活性

7. 優先考慮類型安全的異構容器

開源高性能結構化日誌模塊NanoLog

【簡寫Mybatis-02】註冊機的實現以及SqlSession處理

手繪二維碼

.NET藉助虛擬網卡實現一個簡單異地組網工具

Effective Java（八）

Effective Java（三）

LeetCode刷題之設計題（持續更新）

LeetCode刷題之搜索（持續更新）

輕鬆學會正則表達式！

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結