泛型之泛型類

泛型類

public class A<T> {
    //在成員變量上使用泛型
    private T t;
    
    public A() {}
    
    //構造參數類型上使用泛型
    public A(T t) {
       this.t = t;
    }
    
    //方法返回值上使用泛型
    public T getT() {
        return t;
    }
    
    //方法的參數上使用泛型
    //這是泛型類的方法，而不是泛型方法
    public void setT(T t) {
        this.t = t;
    }
    
    //方法的返回值和參數類型上使用泛型
    public T foo(T t) {
        return t;
    }
    
    public void foo2() {
        //T t = ....; //局部變量的引用類型上使用泛型
        //new T(); //不可以這樣使用
    }
    
    public void foo3() {
        //在創建泛型類對象時，即爲類型變量賦值，這裏將T賦值爲String類型
        A<String> a = new A<String>();
        //將T賦值爲Integer類型
        A<Integer> a1 = new A<Integer>();
    }
}

A是一個泛型類，T它是一個變量，需要賦類型值，如果有多個類型變量，就用逗號分隔，比如 Jdk 的 Map 接口：interface Map<K,V> {}。
定義：具有一個或多個類型變量的類，稱之爲泛型類。
泛型類是一個存在類型變量的類，存在可變的因素，所以說是一個不完整的類。那麼當子類去繼承的時候，把裏面的類型變量賦予了類型，那麼這個類就完整了，就可以使用了。

泛型類的繼承

public class B<T> {}

class BB extends B<String> {}

創建BB對象的兩種方式

• B<String> b = new BB()
• BB b = new BB()

錯誤方式

• BB<String> bb = new BB<String>()

錯誤原因：BB 繼承了泛型類 B，但 BB 並不是泛型類，所以不能這樣創建對象。

public class C<T> {}

class CC<E> extends C<E> {}
class CCC<E> extends C<Integer> {}

創建CC對象

• C<String> c = new CC<String>()
• C<Integer> c = new CC<Integer>()

泛型引用和創建，兩端給出的泛型變量必須相同（等號前後的泛型類型應該保持一致），否則會報錯。
CC是泛型類，它的父類也泛型類，它可以給父類傳遞類型常量，也可以傳遞變量，這裏傳遞的是變量。
CCC同樣是泛型類，它的父類也是泛型類，它傳遞的是常量。

泛型類的子類重寫父類方法

public class D<T> {
    private T bean;
    
    public void setBean(T bean) {
        this.bean = bean;
    }
}

class DD<E> extends D<E> {
    /**
     * 子類重寫父類方法，參數類型必須是E，因爲子類在定義
     * 已經把類型E賦給了父類。
     */
    @Override
    public void setBean(E o) {
        //TODO
    }
}
class DDD<E> extends D<String> {
    //子類定義時已經把類型String賦給了父類，所以方法重寫時類型是String
    public void setBean(String str) {
        //TODO
    }
}