Java泛型是從JDK5中新加入的一個新特性。泛型提供了編譯時型別安全檢測機制，該機制可以在編譯時檢測到非法的型別。

泛型類

定義泛型類：

public class GenericClass<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

測試：

public class DemoGenericClassTest {
    public static void main(String[] args) {
        GenericClass<Integer> gc = new GenericClass<>();
        gc.setName(1);
        Integer name = gc.getName();
        System.out.println(name);
    }
}
 

注：

• 泛型類可能有多個引數，此時應該將多個引數一起放在尖括號內，比如<E1,E2,E3>
• 泛型類的構造器是：public GenericClass(){}，而不是public GenericClass<E>{}

泛型介面

語法：

修飾符 interface 介面名<代表泛型的變數>{}

定義含有泛型的介面：

/**
 * 定義含有泛型的介面
 */
public interface GenericInterface<I> {
    public abstract void method(I i);

}

使用含有泛型介面的第一種方式

建立類實現含有泛型的介面：

/**
  含有泛型的介面，第一種使用方式：定義介面的實現類，實現介面，指定介面的泛型
*/
public class GenericInterfaceImpl1 implements GenericInterface<String> {
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

測試含有泛型的介面：

public class DemoGenericInterfaceTest {
    public static void main(String[] args) {
        GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
        gi1.method("你好");
    }
}
 

使用含有泛型介面的第二種方式

建立類實現介面：

/**
 * 含有泛型的介面第二種使用方式：介面使用什麼型別，實現類就使用什麼泛型，類跟著介面走
 * 就相當於定義一個含有泛型的類，建立物件的時候確定泛型的型別
 */
public class GenericInterfaceImpl2<I> implements GenericInterface<I> {
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

測試：

public class DemoGenericInterfaceTest {
    public static void main(String[] args) {
        GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();
        gi2.method(10);
    }
}

泛型方法

語法：

修飾符 <代表泛型的變數> 返回值型別 方法名(引數){}

定義泛型方法：

public class GenericMethod {
    public <M> void method1(M m) {
        System.out.println(m);
    }

    public static <S> void method2(S s) {
        System.out.println(s);
    }
}

測試如下：

public class DemoGenericMethodTest {
    public static void main(String[] args) {
        //建立GenericMethod物件
        GenericMethod gm = new GenericMethod();
        gm.method1(10);
        gm.method1("abc");
        gm.method1(1.34);

        //使用類名直接呼叫靜態方法
        GenericMethod.method2("def");
        GenericMethod.method2(123);
    }
}

泛型萬用字元

當使用泛型類或者介面時，傳遞的資料中，泛型型別不確定，可以通過萬用字元<?>表示，一旦使用泛型的萬用字元，只能使用Object類中的共性方法，集合元素自身方法無法使用。

當不知道使用什麼型別來接收的時候，此時可以使用?，?表示未知萬用字元。

/**
 * 泛型的萬用字元
 * ?: 代表任意的資料型別
 * 使用方式：
 * 不能建立物件使用
 * 只能作為方法的引數使用
 */
public class DemoGeneric {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(2);

        ArrayList<String> list02 = new ArrayList<>();
        list02.add("a");
        list02.add("b");

        printArray(list01);
        printArray(list02);
    }

    public static void printArray(ArrayList<?> list) {
        Iterator<?> it = list.iterator();
        while (it.hasNext()) {
            Object o = it.next();
            System.out.println(o);
        }
    }
}

泛型的上下限

泛型的上限：

• 型別名稱<? extends 類> 物件名稱：只能接收該型別及其子類

泛型的下限：

• 型別名稱<? super 類> 物件名稱：只能接收該型別及其父型別

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

/**
 * 泛型的上限限定: ? extends E 使用的泛型只能是E型別的子類/本身
 * 泛型的下限限定: ? super E 使用的泛型只能是E型別的父類/本身
 */
public class TestGeneric {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<>();
        Collection<String> list2 = new ArrayList<>();
        Collection<Number> list3 = new ArrayList<>();
        Collection<Object> list4 = new ArrayList<>();
        getElement1(list1);
//        getElement1(list2); //報錯
        getElement1(list3);
//        getElement1(list4); //報錯

//        getElement2(list1); //報錯
//        getElement2(list2); //報錯
        getElement2(list3);
        getElement2(list4);

    }

    //泛型的上限
    public static void getElement1(Collection<? extends Number> coll) {

    }

    //泛型的下限
    public static void getElement2(Collection<? super Number> coll) {

    }
}