Java泛型：泛型類、泛型接口和泛型方法

根據《Java編程思想 （第4版）》中的描述，泛型出現的動機在於：有許多緣由促成了泛型的出現，而最引人注意的一個緣由，就是爲了建立容器類。

泛型類

容器類應該算得上最具重用性的類庫之一。先來看一個沒有泛型的狀況下的容器類如何定義：

public class Container {
    private String key;
    private String value;
    public Container(String k, String v) {
        key = k;
        value = v;
    }
   
    public String getKey() {
        return key;
    }
    public void setKey(String key) {
        this.key = key;
    }
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
}

Container類保存了一對key-value鍵值對，可是類型是定死的，也就說若是我想要建立一個鍵值對是String-Integer類型的，當前這個Container是作不到的，必須再自定義。那麼這明顯重用性就很是低。

固然，我能夠用Object來代替String，而且在Java SE5以前，咱們也只能這麼作，因爲Object是全部類型的基類，因此能夠直接轉型。可是這樣靈活性仍是不夠，由於仍是指定類型了，只不過此次指定的類型層級更高而已，有沒有可能不指定類型？有沒有可能在運行時才知道具體的類型是什麼？

因此，就出現了泛型。

public class Container<K, V> {
    private K key;
    private V value;

    public Container(K k, V v) {
        key = k;
        value = v;
    }

    public K getKey() {
        return key;
    }

    public void setKey(K key) {
        this.key = key;
    }

    public V getValue() {
        return value;
    }

    public void setValue(V value) {
        this.value = value;
    }
}

 在編譯期，是沒法知道K和V具體是什麼類型，只有在運行時纔會真正根據類型來構造和分配內存。能夠看一下如今Container類對於不一樣類型的支持狀況：

public class Main {

    public static void main(String[] args) {
        Container<String, String> c1 = new Container<String, String>("name", "findingsea");
        Container<String, Integer> c2 = new Container<String, Integer>("age", 24);
        Container<Double, Double> c3 = new Container<Double, Double>(1.1, 2.2);
        System.out.println(c1.getKey() + " : " + c1.getValue());
        System.out.println(c2.getKey() + " : " + c2.getValue());
        System.out.println(c3.getKey() + " : " + c3.getValue());
    }
}

 輸出：

name : findingsea
age : 24
1.1 : 2.2

 泛型接口

在泛型接口中，生成器是一個很好的理解，看以下的生成器接口定義：

public interface Generator<T> {
    public T next();
}

 而後定義一個生成器類來實現這個接口：

public class FruitGenerator implements Generator<String> {

    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

 調用：

public class Main {

    public static void main(String[] args) {
        FruitGenerator generator = new FruitGenerator();
        System.out.println(generator.next());
        System.out.println(generator.next());
        System.out.println(generator.next());
        System.out.println(generator.next());
    }
}

 能夠看到方法的參數完全泛化了，這個過程涉及到編譯器的類型推導和自動打包，也就說原來須要咱們本身對類型進行的判斷和處理，如今編譯器幫咱們作了。這樣在定義方法的時候沒必要考慮之後到底須要處理哪些類型的參數，大大增長了編程的靈活性。

再看一個泛型方法和可變參數的例子：

輸出和前一段代碼相同，能夠看到泛型能夠和可變參數很是完美的結合。

以上，泛型的第一部分的結束