1. ArrayList al1 = new ArrayList ();  
2. al1.add("abc");  
3. al1.add("789");  
4. al1.add("ddd");  
5. al1.add(3);  
6. ListIterator it = al1.listIterator();  
7.     while (it.hasNext()) {  
8.         String str = (String)it.next();  
9.         System.out.println(str);  
10.     }  

ArrayList al1 = new ArrayList ();
al1.add("abc");
al1.add("789");
al1.add("ddd");
al1.add(3);

ListIterator it = al1.listIterator();
	while (it.hasNext()) {
			
		String str = (String)it.next();
		System.out.println(str);
	}
 

這種寫法就會造成類轉換異常，為了解決這樣的問題，在JDK1.5中引入了一種機制——泛型機制。這種機制的好處是，把只能在執行時才能觀察到的錯誤提前到編譯時就能發現，及時解決。

例如，將以上程式碼中例項化ArrayList時，變成如下格式

ArrayList<String> al1 = new ArrayList<String>();

就會在編譯時，對al1.add(3)進行檢查，然後報錯，當然，迭代器也可以使用泛型機制：ListIterator<String> it = al1.listIterator();這樣就避免了在迴圈中取出元素再進行強制型別轉換了。

以上程式碼用泛型機制寫就是如下形式：

1. ArrayList<String> al1 = new ArrayList<String>();  
2. al1.add("abc");  
3. al1.add("789");  
4. al1.add("ddd");  
5. ListIterator<String> it = al1.listIterator();  
6.     while (it.hasNext()) {  
7.         String str = it.next();  
8.         System.out.println(str);  
9.     }  

ArrayList<String> al1 = new ArrayList<String>();
al1.add("abc");
al1.add("789");
al1.add("ddd");

ListIterator<String> it = al1.listIterator();
	while (it.hasNext()) {
			
		String str = it.next();
		System.out.println(str);
	}

在宣告一個類時候使用泛型

自定義一個類，若要用到泛型，可以用如下形式：

1. class Student<T> {  
2.     T t;  
3. }  

class Student<T> {
	T t;
	
}

在自定義的類中，實現帶有泛型的方法：

1. class Student {  
2.     public <T> void show(T t) {  
3.     }  
4. }  

class Student {
	public <T> void show(T t) {
	}
}

或者

1. class Student <T> {  
2.     publicvoid show(T t) {  
3.     }  
4. }  

class Student <T> {
	public void show(T t) {
	}
}

但是用如此形式定義的泛型，是不支援靜態方法的。因為靜態方法是隨著類的載入而進入方法區的，而泛型具體是什麼型別是在例項化物件時才明確的，也就是說，泛型代表的型別明確晚於靜態方法載入，這樣會使其要操作的物件型別不明確，如果必須在靜態方法上使用泛型，可以用如下形式：

1. publicstatic <T> void show(T t) {  
2. }  
3. 介面上使用泛型：  
4. interface Inte <T> {  
5. void show (T t);  
6. }  
7. 然後用類來實現這個介面，  
8. class InteClass implements Inte<String> {  
9. void show ()｛  
10. ｝  
11. }  
12. 如果在定義類的時候，仍然不明確資料型別，就可以採用如下方式，  
13. class InteClass <T> implements Inte<T> {  
14. void show (T t) {  
15. }  
16. }  

public static <T> void show(T t) {
}
介面上使用泛型：
interface Inte <T> {
void show (T t);
}
然後用類來實現這個介面，
class InteClass implements Inte<String> {
void show ()｛
｝
}
如果在定義類的時候，仍然不明確資料型別，就可以採用如下方式，
class InteClass <T> implements Inte<T> {
void show (T t) {
}
}

泛型的擴充套件：

泛型的擴充套件主要有兩種表現形式，<? extends E>和<? super E>,這兩種方式都是用來指定泛型可表示類的範圍，前者是用來指定上限的，該類及其子類適用；後者是用來指定下限的，該類及其父類適用。