《Java核心技術卷一》之 泛型

1、引言

在學習集合的時候咱們會發現一個問題，將一個對象丟到集合中後，集合並不記住對象的類型，通通都當作Object處理，這樣咱們取出來再使用時就得強制轉換類型，致使代碼臃腫，並且加入集合時都是以Object，沒作類型檢查，那麼強制轉換就容易出錯，泛型的誕生就是爲解決這些問題。

2、使用泛型

泛型是如何解決這個問題呢？按照上面的問題，咱們只須要在建立集合時指定集合元素的類型，那麼集合就能記住對象的類型，那當咱們加入是就只能按照指定的類型進行加入，而取出使用時也不須要強制轉換：

ArrayList<Integer> list = new ArrayList<Integer>();

這是Java 7以前的寫法，很明顯構造器上面的泛型沒有必要，如今推薦如下寫法：

ArrayList<Integer> list = new ArrayList<>();

既然我已經指定了類型，那麼添加時只能添加Integer，而且使用時能夠直接當作Integer使用

System.out.println(list.get(2)+3);

這種參數化類型就是泛型，泛型就是容許在定義類、接口、方法時使用類型形參，這個參數形參將在申明變量、建立對象、調用方法時動態指定。

3、 定義泛型接口、類

來看看List接口和Map接口的定義：

public interface List<E> extends Collection<E>
public interface Map<K,V>

List接口定義時指定了一個類型形參，Map接口定義了兩個類型形參。接口定義了形參以後，在接口中形參就能夠當作一種類型來使用，那麼其中的方法就可使用類型形參

boolean add(E e);

這種方式其實也是一種代碼複用，咱們經過類型形參，高度的將參數抽象，而不須要每種類型都去從新定義類，只要在使用時肯定類型便可。咱們也能夠自定義泛型類

public class WebResult<T> {
    //使用T類型形參定義實例變量
    private T data;

    public WebResult() {
    }
    //使用T類型形參構造對象
    public WebResult(T data) {
        this.data = data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public T getData() {
        return this.data;
    }

    public static void main(String[] args) {
        WebResult<String> webResult = new WebResult<>("返回一個String對象");
        System.out.println(webResult.getData());
        WebResult<Integer> webResult1 = new WebResult<>(10);
        System.out.println(webResult1.getData());
    }

}

4、通配符

先看下面這段代碼：

public static void main(String[] str){
    ArrayList<String> arrayList=new ArrayList();
    test(arrayList);
}

public static void test(List<Object> test){
    for (int i = 0; i <test.size() ; i++) {
        System.out.println(test.get(i));
    }
}

這段代碼會出現編譯錯誤，由於List<String>對象不能做爲List<Object>使用，這說明泛型不是協變的，由於以前數組的設計是協變的，致使存在安全性問題，而泛型的設計原則是編譯時不出現警告就不會出現類型轉換錯誤，那爲了表示各類泛型的父類，就引入了通配符：？這個問號表明能夠是匹配任何類型。

將方法修改：

public static void test(List<?> test){
    for (int i = 0; i <test.size() ; i++) {
        System.out.println(test.get(i));
    }
}

這樣即可以順利編譯，咱們再加上這段代碼：

public static void main(String[] str){
    ArrayList<String> arrayList=new ArrayList();
    test(arrayList);
    List<?> strings = arrayList;
    strings.add("abc");
}

這裏咱們能夠將arrayList給strings，按說這個時候是不能賦值的，由於List不知道類型參數的值，這是編譯器做用，能夠進行類型推理，可是後面的strings.add("abc")是不能經過編譯的，編譯器不能對 List 的類型參數做出足夠嚴密的推理，以肯定將 String 傳遞給 List.add() 是類型安全的。因此編譯器將不容許這麼作。

4.1 設置通配符上限

List<?>這種方式，通配的是全部的類型，不少時候咱們能夠肯定是哪一類對象能夠添加進去，咱們只但願它表明某一類泛型的父類，這個時候咱們能夠設置通配符的上限。

//動物類
public abstract class Animal {
    public abstract void say();
}

public class Cat extends Animal {
    @Override
    public void say() {
        System.out.println("喵喵");
    }
}

public class Dog extends Animal {

    @Override
    public void say() {
        System.out.println("旺旺");
    }
}

這個時候咱們就限定了上限

public static void test1(List<? extends Animal> animals) {
    for (int i = 0; i < animals.size(); i++) {
        animals.get(i).say();
    }
}

咱們也能夠直接在定義類型形參的時候設置上限

public class WebResult<T extends Animal> {

4.2 通配符下限

既然有設置上限，那也有設置下限，那在什麼狀況下會使用下限呢？看個例子

//將src中的集合複製到dest，並返回最後一個值
public static <T> T copy(Collection<T> dest, Collection<? extends T> src) {
    T last = null;
    for (T ele : src) {
        last = ele;
        dest.add(ele);
    }
    return last;
}

功能比較很簡單，將src中的集合複製到dest，並返回src最後一個值

List<Number> ln = new ArrayList<>();
List<Integer> li = new ArrayList<>();
//編譯出錯，類型不肯定
Integer last = copy(ln, li);

這個時候出錯，由於雖然咱們知道返回的值必定是Integer，可是因爲copy方法的返回值並非，全部至關於咱們在複製的過程當中丟失了src的類型，若是咱們想定義約束關係使得返回值明確即：dest集合元素類型與src的關係要麼相同要麼是其父類，爲了表示這種約束關係，引入了<? super T> 這個通配符表示它必須是T自己或者T的父類。

//將src中的集合複製到dest，並返回最後一個值
public static <T> T copy(Collection<? super T> dest, Collection<? extends T> src) {
    T last = null;
    for (T ele : src) {
        last = ele;
        dest.add(ele);
    }
    return last;
}

5、泛型方法

除了泛型接口和泛型類，咱們還能夠定義泛型方法，寫法以下：

static <T> void arrayToList(T[] a, List<T> list) {
    for (T o : a) {
        list.add(o);
    }
}

調用以下：

Object[] objects = new Object[10];
List<Object> list = new ArrayList<>();
arrayToList(objects, list);

Integer[] integers = new Integer[10];
List<Integer> integerList = new ArrayList();
arrayToList(integers, integerList);

String[] strings = new String[10];
List<String> stringList = new ArrayList<>();
arrayToList(strings, stringList);
//編譯錯誤，類型不正確
arrayToList(strings, integerList);

這裏能夠看出泛型方法跟類型通配符的功能有點相似，其實在大部分狀況下咱們能夠用泛型方法代替類型通配符。

泛型方法容許類型形參被用來表示方法的一個或者多個參數之間的依賴關係，或者說與返回值之間的關係，若是沒有這種關係，咱們就不使用泛型方法。

6、擦除與轉換

當把一個具備泛型信息的對象賦給一個沒有泛型信息的變量時，全部的類型信息就都丟掉了，好比List<String>類型被轉換成List,則對該List的類型檢查也變成了Object。

public class WebResult<T extends Number> {
    //使用T類型形參定義實例變量
    private T data;

    public WebResult() {
    }

    //使用T類型形參構造對象
    public WebResult(T data) {
        this.data = data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public T getData() {
        return this.data;
    }

    public static void main(String[] args) {
        WebResult<Integer> webResult1 = new WebResult<>(10);
        System.out.println(webResult1.getData());
        WebResult<Integer> a = new WebResult<>(20);
        WebResult b = a;
        //已經擦除了泛型，只能按最高類型Object
        //Integer bData = b.getData();
        Object object=b.getData();
    }

}

本來的泛型類上限是Number，而當把a賦給擦除泛型的b對象時，編譯器失去了推斷能力，只能把其當作Objec來處理。

而當一個List轉成泛型對象是java是容許的

List<Integer> integerList = new ArrayList<>();
List stringList = integerList;
//容許直接將list對象轉換給
List<String> strings = stringList;
//直接獲取數據會出現錯誤，由於轉換不成功
System.out.println(stringList.get(0));