目錄
1. 為什么要有泛型
1.1 不使用泛型的問題
當不使用泛型時，集合中是可以存放任意類型對象的，只要把對象存儲集合后，那么他們都會被提升為Object類型。當我們在取出每一個對象，並且進行相應的操作，需要進行類型轉換。
觀察下面代碼：
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add("abc");
coll.add("def");
coll.add(5);//由於集合沒有做任何限定，任何類型都可以存放
Iterator it = coll.iterator();
while(it.hasNext()){
//需要打印每個字符串的長度,就要把迭代出來的對象轉成String類型
String str = (String) it.next();
System.out.println(str.length());
}
}
程序在運行時發生了問題 java.lang.ClassCastException。為什么會發生類型轉換異常呢？
由於集合沒有使用泛型，什么類型的元素都可以存儲，導致取出時強轉引發運行時 ClassCastException。怎么來解決這個問題呢？
Collection雖然可以存儲各種類型對象，但一般只存儲同一類型對象，例如都是字符串對象。因此在JDK5之后，新增了泛型(Generic)語法，讓你在設計API時可以指定類或方法支持泛型，這樣我們使用API的時候也變得更為簡潔，並得到了編譯時期的語法檢查。
1.2 泛型概念
泛型：參數化類型，也就是說要操作的數據一開始不確定是什么類型，在使用的時候，才能確定是什么類型，把要操作的數據類型指定為一個參數，在使用時傳入具體的類型，實現代碼的模板化。
//比如ArrayList集合(含有泛型)，部分源代碼如下(可以理解為模板)
public class ArrayList<E> {
public E get(int index) {...}
public E set(int index, E element) {...}
public boolean add(E e) {...}
public E remove(int index) {...}
}
//創建ArrayList集合對象指定類型為String時
List<String> list1 = new ArrayList<>();
//模板代碼相當於變成如下形式
public class ArrayList<String> {
public String get(int index) {...}
public String set(int index, String element) {...}
public boolean add(String e) {...}
public String remove(int index) {...}
}
//所以使用list1集合對象，調用以上四個方法時，所有E的位置都變為了String
//創建ArrayList集合對象指定類型為Integer時
List<Integer> list2 = new ArrayList<>();
//模板代碼相當於變成如下形式
public class ArrayList<Person> {
public Integer get(int index) {...}
public Integer set(int index, Integer element) {...}
public boolean add(Integer e) {...}
public Integer remove(int index) {...}
}
//所以使用list2集合對象，調用以上四個方法時，所有E的位置都變為了Integer
jdk1.7之后，泛型的簡化操作：ArrayList
flist = new ArrayList<>(); 可省略右側 中的數據類型。
1.3 使用泛型的好處
-
將運行時期的ClassCastException，提前到編譯時期變成了編譯失敗
-
避免了類型強轉的麻煩。
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class GenericDemo {
public static void main(String[] args) {
show02();
}
/**
* 創建集合對象，使用泛型
* 好處:
* 1.想使用元素特有的方法，避免了類型轉換的麻煩
* 2.把運行時異常，提升到編譯時期
* 弊端:
* 一旦確定數據類型，就只能存儲該類型數據
*/
private static void show02() {
Collection<String> list = new ArrayList<>();
list.add("abc");
list.add("def");
// list.add(5);//當集合明確類型后，存放類型不一致就會編譯報錯
// 集合已經明確具體存放的元素類型，那么在使用迭代器的時候，迭代器也同樣會知道具體遍歷元素類型
Iterator<String> it = list.iterator();
while(it.hasNext()){
String str = it.next();
//當使用Iterator<String>控制元素類型后，就不需要強轉了。獲取到的元素直接就是String類型
System.out.println(str.length());
}
}
/**
* 創建集合對象，不使用泛型
* 好處:
* 集合的類型默認為Object類型，可以存儲任意的對象
* 弊端:
* 不安全，
* 不能使用元素特有的方法
*/
private static void show01() {
ArrayList list = new ArrayList();
list.add("abc");
list.add(1);
//使用迭代器遍歷集合
Iterator it = list.iterator();
while(it.hasNext()){
//取出集合中元素，Object類型
Object obj = it.next();
System.out.println(obj);
/*
想使用字符串特有的方法length
不能使用，需要向下轉型
Object obj = "abc";多態
*/
String s = (String)obj;
System.out.println(s.length());
}
}
}
2. 泛型類
2.1 定義格式：
//其中類型參數，一般用一個大寫字母表示，比如: T,E,K,V
//如果要定義多個泛型，多個類型參數之間用逗號,隔開，例如：public class HashMap<K,V> {...}
權限修飾符 class 類名<類型形參> { }
例如，API中的ArrayList集合：
泛型在定義的時候不具體，使用的時候才變得具體。在使用的時候確定泛型的具體數據類型。
public class ArrayList<E>{
public boolean add(E e){ }
public E get(int index){ }
....
}
2.2 使用泛型： 即什么時候確定泛型。
在創建對象的時候指定類型
例如，ArrayList<String> list = new ArrayList<>();
此時，變量E的值就是String類型，那么我們的類型就可以理解為：
class ArrayList<String>{
public boolean add(String e){ }
public String get(int index){ }
...
}
再例如，ArrayList<Integer> list = new ArrayList<>();
此時，變量E的值就是Integer類型，那么我們的類型就可以理解為：
class ArrayList<Integer> {
public boolean add(Integer e) { }
public Integer get(int index) { }
...
}
在類、接口上聲明的泛型，在本類、本接口中即代表某種數據類型，可以作為非靜態成員變量的類型、非靜態方法的形參類型、非靜態方法的返回值類型、局部變量的類型等，但不能用於靜態成員上。
自定義泛型類：
public class MyGenericClass<T> {
// 沒有T類型，在這里代表 未知的一種數據類型 未來傳遞什么就是什么類型
private T t; // 用於成員變量的數據類型
public MyGenericClass() {
}
public MyGenericClass(T t) { // 用於方法的形參的數據類型
this.t = t;
}
public T getT() { // 用於方法的返回值的數據類型
return t;
}
public void setT(T t) {
this.t = t;
}
public void test() { // 用於局部變量的數據類型
T t;
}
}
使用:
public class GenericClassDemo {
public static void main(String[] args) {
// 創建一個泛型為String的類
MyGenericClass<String> gc1 = new MyGenericClass<>();
// 調用setT
gc1.setT("abc");
// 調用getT
String str = gc1.getT();
System.out.println(str);
//創建一個泛型為Integer的類
MyGenericClass<Integer> gc2 = new MyGenericClass<>();
gc2.setT(123);
Integer num = gc2.getT();
System.out.println(num);
}
}
注意：
類型實參必須是一個類類型，不能用基本數據類型填充，但可以使用包裝類。
繼承中的使用：
父類：
public class MyGenericFuClass<T> {
public void print(T t) {
System.out.println(t);
}
}
- 定義子類繼承泛型父類的同時指定泛型的類型
public class MyGenericZiClassA extends MyGenericFuClass<Integer> {
@Override
public void print(Integer num) {
System.out.println(num);
}
}
public static void main(String[] args) {
// MyGenericZiClassA類已經沒有泛型了
MyGenericZiClassA gzA = new MyGenericZiClassA();
gzA.print(100);
}
- 定義子類繼承泛型父類，若不指定的父類泛型類型，子類也必須聲明為泛型類，創建對象時指定泛型的類型
public class MyGenericZiClassB<T> extends MyGenericFuClass<T> {
@Override
public void print(T t) {
System.out.println(t);
}
}
public static void main(String[] args) {
//創建對象指定泛型類型為String
MyGenericZiClassB<String> gzB = new MyGenericZiClassB<>();
gzB.print("abc");
//gzB.print(100);//錯誤，只能傳遞String類型的參數
//創建對象指定泛型類型為Integer
MyGenericZiClassB<Integer> gzB2 = new MyGenericZiClassB<>();
gzB2.print(100);
}
3. 泛型接口
3.1 定義格式：
權限修飾符 interface 接口名<類型形參> {...}
例如，
public interface MyGenericInterface<T> {
//抽象方法
public abstract void show(T t);
}
3.2 使用方式：
1、定義實現類的同時指定泛型接口上的的具體數據類型
public class MyGenericInterfaceImplA implements MyGenericInterface<String> {
@Override
public void show(String s) {
System.out.println(s);
}
}
public class MyGenericInterfaceDemo1 {
public static void main(String[] args) {
MyGenericInterfaceImplA mi = new MyGenericInterfaceImplA();
// 已指定String類型，只能傳字符串
mi.show("abc");
}
}
2、定義實現類時，若不指定接口上的泛型的具體數據類型，實現類也必須指定為泛型類，創建對象時，確定泛型的類型
public class MyGenericInterfaceImplB<T> implements MyGenericInterface<T> {
@Override
public void show(T t) {
System.out.println(t);
}
}
public class MyGenericInterfaceDemo2 {
public static void main(String[] args) {
//創建對象指定泛型類型為String
MyGenericInterfaceImplB<String> mi = new MyGenericInterfaceImplB<>();
mi.show("abc");
//創建對象指定泛型類型為Integer
MyGenericInterfaceImplB<Integer> mi2 = new MyGenericInterfaceImplB<>();
mi2.show(100);
}
}
4. 泛型類、泛型接口小結：
-
語法格式：
-
在創建泛型類、泛型接口的對象時，為泛型形參指定具體類型
-
在繼承泛型類或實現泛型接口時，為泛型形參指定具體類型
-
-
異常類不能是泛型的
-
不能使用new E[]。但是可以：E[] array = (E[])new Object[size]; E[] array = (E[])new Object[]{...};等
-
父類有泛型，子類可以選擇保留泛型也可以選擇指定泛型類型：
- 子類不保留父類的泛型：按需傳參
- 沒有類型 擦除
- 具體類型
- 子類保留父類的泛型：泛型子類
- 全部保留
- 部分保留
- 結論：子類除了指定或保留父類的泛型，還可以增加自己的泛型（可類推到接口繼承、接口實現）
- 子類不保留父類的泛型：按需傳參
class Father<T1, T2> {
}
// 子類不保留父類的泛型
// 1)沒有類型 擦除
class Son1 extends Father {// 等價於class Son extends Father<Object,Object>{
}
// 2)具體類型
class Son2 extends Father<Integer, String> {
}
// 子類保留父類的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}
增加自己的泛型：
class Father<T1, T2> {
}
// 子類不保留父類的泛型
// 1)沒有類型 擦除
class Son<A, B> extends Father{//等價於class Son extends Father<Object, Object>{
}
// 2)具體類型
class Son2<A, B> extends Father<Integer, String> {
}
// 子類保留父類的泛型
// 1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {
}