手机日韩,欧美日韩国产高清,偷牌自拍

Java泛型你必須知道的知識

一什么是泛型

Java 泛型(generics)是 JDK 5 中引入的一個新特性, 泛型提供了編譯時類型安全檢測機制，該機制允許程序員在編譯時檢測到非法的類型。

簡單理解就是：泛型指定編譯時的類型，減少運行時由于對象類型不匹配引發的異常。其主要用途是提高我們的代碼的復用率。

我們Java標準庫中的ArrayList就是泛型使用的典型應用：

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {



      ......

    public ArrayList(Collection<? extends E> c) {

        elementData = c.toArray();

        if ((size = elementData.length) != 0) {

            // c.toArray might (incorrectly) not return Object[] (see 6260652)

            if (elementData.getClass() != Object[].class)

                elementData = Arrays.copyOf(elementData, size, Object[].class);

        } else {

            // replace with empty array.

            this.elementData = EMPTY_ELEMENTDATA;

        }

    }

    public void sort(Comparator<? super E> c) {

        final int expectedModCount = modCount;

        Arrays.sort((E[]) elementData, 0, size, c);

        if (modCount != expectedModCount) {

            throw new ConcurrentModificationException();

        }

        modCount++;

    }



  .....

    public E get(int index) {

        rangeCheck(index);

        return elementData(index);

    }

    public boolean add(E e) {

        ensureCapacityInternal(size + 1);  // Increments modCount!!

        elementData[size++] = e;

        return true;

    }

}

源碼中，ArrayList中的E稱為類型參數變量，而整個ArrayList我們稱為泛型類型。我們可以指定除基本類型之外的任何類型，如：ArrayList。
源碼中Collection中? 通配符類型表示類型的上界，表示參數化類型的可能是T 或是 T的子類。
源碼中Comparator表示類型下界(Java Core中叫超類型限定)，表示參數化類型是此類型的超類型(父類型)，直至Object。

二 extends和super通配符

在定義泛型類型Generic的時候，也可以使用extends通配符來限定T的類型：

public class Generic<T extends Number> { ... }

現在，我們只能定義：

Generic<Number> p1 = null;

Generic<Integer> p2 = new Generic<>(1, 2);

Generic<Double> p3 = null;

因為Number、Integer和Double都符合。

非Number類型將無法通過編譯：

Generic<String> p1 = null; // compile error!

Generic<Object> p2 = null; // compile error!

因為String、Object都不符合，因為它們不是Number類型或Number的子類。

我們看一個例子：

public class Test {

    static class Food {

    }

    static class Fruit extends Food {

    }

    static class Apple extends Fruit {

    }

    static class Orange extends Fruit {

    }

    public void testExtend() {

        List<? extends Fruit> list = new ArrayList<Apple>();

        //無法安全添加任何具有實際意義的元素,報錯,extends為上界通配符,只能取值,不能放.

        //因為Fruit的子類不只有Apple還有Orange,這里不能確定具體的泛型到底是Apple還是Orange，所以放入任何一種類型都會報錯

        //list.add(new Apple());

        //list.add(new Orange());

        //可以添加null，因為null可以表示任何類型

        list.add(null);

        //可以正常獲取，用java多態

        Food foot = list.get(0);

        Apple apple = (Apple) list.get(0);

    }

    public void testSuper() {

        List<? super Fruit> list = new ArrayList<Fruit>();

        //super為下界通配符，可以存放元素，但是也只能存放當前類或者子類的實例，以當前的例子來講，

        list.add(new Fruit());

        list.add(new Apple());

        //無法確定Fruit的父類是否只有Food一個(Object是超級父類)

        //因此放入Food的實例編譯不通過，只能放自己的實例或者根據java多態的特性放子類實例

        //list.add(new Food());

        //List<? super Fruit> list2 = new ArrayList<Apple>();

        //Fruit fruit = list.get(0); //不能確定返回類型

    }

}

在testExtend方法中，因為泛型中用的是extends，在向list中存放元素的時候，我們并不能確定List中的元素的具體類型，即可能是Apple也可能是Orange。因此調用add方法時，不論傳入new Apple()還是new Orange()，都會出現編譯錯誤。

理解了extends之后，再看super就很容易理解了，即我們不能確定testSuper方法的參數中的泛型是Fruit的哪個父類，因此在調用get方法時只能返回Object類型。結合extends可見，在獲取泛型元素時，使用extends獲取到的是泛型中的上邊界的類型(本例子中為Fruit),范圍更小。

總結：

在使用泛型時，存取元素時用super。
獲取元素時，用extends。

有了上面的結論我們看下Java標準庫的Collections類定義的copy()方法，這個copy()方法的定義就完美地展示了extends和super的意圖：

copy()方法內部不會讀取dest，因為不能調用dest.get()來獲取T的引用;
copy()方法內部也不會修改src，因為不能調用src.add(T)。

public class Collections {

    // 把src的每個元素復制到dest中:

    public static <T> void copy(List<? super T> dest, List<? extends T> src) {

        for (int i=0; i<src.size(); i++) {

            T t = src.get(i);

            dest.add(t);

        }

    }

}

三泛型擦除

Java的泛型是偽泛型，這是因為Java在編譯期間，所有的泛型信息都會被擦掉，正確理解泛型概念的首要前提是理解類型擦除。Java的泛型基本上都是在編譯器這個層次上實現的，在生成的字節碼中是不包含泛型中的類型信息的，使用泛型的時候加上類型參數，在編譯器編譯的時候會去掉，這個過程成為類型擦除

我們看一個示例：

public class Test2 {

    public static void main(String[] args) {

        Map<String, Animal> map = new HashMap<>();

        Animal animal = new Animal();

        animal.setVegetarian(true);

        animal.setEats("fish");

        map.put("cat", animal);

        String json = new Gson().toJson(map);

        System.out.println(json);

        Map<String, Animal> jsonToMap = fromJson(json);

        System.out.println(jsonToMap);

        Animal animal1 = jsonToMap.get("cat");

        System.out.println(animal1.getEats());

    }

    public static <T> T fromJson(String str) {

        return new Gson().fromJson(str, new TypeToken<T>() {

        }.getType());

    }

}

上的代碼運行會提示如下異常：

Exception in thread "main" java.lang.ClassCastException: com.google.gson.internal.LinkedTreeMap cannot be cast to com.uaf.rabbitmq.producer.Animal

at com.uaf.rabbitmq.producer.Test2.main(Test2.java:30)

異常原因主要是這句：new Gson().fromJson(str, new TypeToken() {}.getType());

這句在實際執行的時候，List中的T并未傳入實際的泛型參數，導致Gson按照LinkedTreeMap來解析JSON，以致發生了錯誤;這就是一個在編譯期泛型類型擦除所導致的問題;

解決這個問題我們需要修改fromJson方法

public class Test2 {

    public static void main(String[] args) {

        Map<String, Animal> map = new HashMap<>();

        Animal animal = new Animal();

        animal.setVegetarian(true);

        animal.setEats("fish");

        map.put("cat", animal);

        String json = new Gson().toJson(map);

        System.out.println(json);

        Map<String, Animal> jsonToMap = fromJson(json,

        new TypeToken<Map<String, Animal>>() {}.getType());

        System.out.println(jsonToMap);

        Animal animal1 = jsonToMap.get("cat");

        System.out.println(animal1.getEats());

    }

    public static <T> T fromJson(String str, Type type) {

        return new Gson().fromJson(str, type);

    }

}