Java 從入門到進階之路（二十三）

在之前的文章我們介紹了一下 Java 中的  集合框架中的Collection 的迭代器 Iterator，本章我們來看一下 Java 集合框架中的Collection 的泛型。

在講泛型之前我們先來看下面一段程式碼：

public class Main {
    public static void main(String[] args) {
        Point point = new Point(1, 2);

        point.setX(2);
        int ix = point.getX();
        System.out.println(ix); // (2, 2)

        /**
         * 如果想要 x 值變為 double 型別則可以強轉為 double 型別
         * */
        point.setX(2);
        double dx = (double) point.getX();
        System.out.println(dx); // 2.0
    }
}

class Point {
    private int x;
    private int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    @Override
    public String toString() {
        return "(" + x + ", " + y + ")";
    }
}

上面的程式碼我們之前的文章講過，我們可以通過傳入 x 和 y 值來定義 Point 點，如果我們想要 double 型別的點時需要造型為 double 型別，那我要定義漢字型別的呢？那就造型成 String 型別，這就很麻煩，每次都需要自己來造型，有種鞋不合腳的感覺，那能不能定義我想要什麼型別就是什麼型別呢，如下：

public class Main {
    public static void main(String[] args) {
        Point<Integer> point1 = new Point<Integer>(1, 2); // 必須是包裝類
        point1.setX(1);
        System.out.println(point1.getX()); // 1

        Point<Double> point2 = new Point<Double>(1.1, 2.1); // 必須是包裝類
        point2.setX(1.2);
        System.out.println(point2.getX()); // 1.2

        Point<String> point3 = new Point<String>("一", "二"); // 必須是包裝類
        point3.setX("三");
        System.out.println(point3.getX()); // 三
    }
}

/**
 * 泛型
 * 又稱引數化型別，是將當前類的屬性的型別，方法引數的型別及方法
 * 返回值的型別的定義權移交給使用者，
 * 使用者在建立當前類的同時將泛型的試劑型別傳入
 * 數字和字母組合，數字不能開頭
 */
class Point<T> { // 定義為泛型 T 型別
    private T x;
    private T y;

    public Point(T x, T y) {
        this.x = x;
        this.y = y;
    }

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }

    public T getY() {
        return y;
    }

    public void setY(T y) {
        this.y = y;
    }

    @Override
    public String toString() {
        return "(" + x + ", " + y + ")";
    }
}

從上面的程式碼中，我們定義了一個 T 的型別 Point，當我們要例項化該類時，根據自己的需求傳入想要的包裝類型別即可，這樣就滿足了不同的需求，各取所需。 

泛型從底層來說其實就是 Object，定義了泛型只是編譯器在做一些驗證工作，當我們對泛型型別設定值時，會檢查是否滿足型別要求，當我們獲取一個泛型型別的值時，會自動進行型別轉換。

在平時我們是很少自己來定義泛型的，泛型是用來約束集合中元素的型別，如下：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<String>(); // 只能新增 String 型別的元素
        collection.add("one");
        collection.add("two");
        collection.add("thee");
        collection.add("four");
        // collection.add(1); // 編譯錯誤
        for (String string : collection) {
            System.out.println(string); // one two three four
        }
        Iterator<String> iterator = collection.iterator();
        while (iterator.hasNext()) {
            // String string = (String) iterator.next(); 不需要再造型
            String string = iterator.next();
            System.out.println(string); // one two three four
        }
    }
}