泛型是一種把類型明確的工作推遲到創建對象或者調用方法的時候才去明確的特殊的類型。

泛型的格式：

　　　　<數據類型>

　　　　注意：此處的數據類型這能是引用類型

　　　　好處：

　　　　　　A：把運行時期的問題提前到了編譯期間

　　　　　　B：避免了強制類型轉換

　　　　　　C：優化了程序設計

import java.util.ArrayList;public class ArrayListDemo {    public static void main(String[] args) {        ArrayList array = new ArrayList();        array.add("hello");        array.add("world");        array.add("java");for (int x = 0; x < array.size(); x++) {            String s = (String) array.get(x);//由于沒有使用泛型所以要進行強制類型轉換            System.out.PRintln(s);        }    }}

那么泛型在什么地方要使用呢？

　　我們可以查看API，如果類、接口和抽象類的后面跟有<E>就說明要使用泛型，一般來說就是在集合中使用。

泛型的由來：

　　在早期的時候我們可以使用Object類型來接收任意的對象類型，但是在實際的使用過程中，向上轉型是沒有任何問題的，但是在向下轉型的時候其實隱含了類型轉換的問題，會有強制類型轉換的問題，也就存在著隱患，所以Java在JDK5以后就提供了泛型來解決這個安全問題，提高程序的安全性。

泛型的應用：

　　A：泛型類

　　　　就是把泛型定義在類上

　　　　格式：public class 類名<泛型類型 1,...>

　　　　注意：泛型的類型必須是引用類型

//定義一個泛型類 class ObjectTool<T> {private T obj;public T getObj() {return obj;}public void setObj(T obj) {this.obj = obj;}}//定義一個測試類public class ObjectToolDemo {public static void main(String[] args) {ObjectTool<String> ot = new ObjectTool<String>();// ot.setObj(new Integer(27)); //這個時候編譯期間就過不去ot.setObj(new String("林青霞"));String s = ot.getObj();System.out.println("姓名是：" + s);ObjectTool<Integer> ot2 = new ObjectTool<Integer>();// ot2.setObj(new String("風清揚"));//這個時候編譯期間就過不去ot2.setObj(new Integer(27));Integer i = ot2.getObj();System.out.println("年齡是：" + i);}}

　　B：泛型方法

　　　　就是把泛型定義在了方法上

　　　　格式：public<泛型類型> 返回類型 方法名(泛型類型)　　

　　　　好處：方法可以接收任意類型的數據

public class ObjectTool {    //定義一個泛型方法public <T> void show(T t) {System.out.println(t);}}//定義一個測試類public class ObjectToolDemo {public static void main(String[] args) {// 定義泛型方法后ObjectTool ot = new ObjectTool();ot.show("hello");ot.show(100);ot.show(true);}}

　　C：泛型接口

　　　　就是把泛型定義在接口上

　　　　格式：public interface 接口名<泛型類型1...>

　　　　泛型接口的實現類在實現接口的時候分以下兩種情況

　　　　第一種情況：實現該接口的時候已經知道是什么類型

//定義一個泛型接口 interface Inter<T> {public abstract void show(T t);}//泛型類的實現類在實現接口是知道是什么類型的了public class InterImpl implements Inter<String> {@Overridepublic void show(String t) {System.out.println(t);} }//測試類public class InterDemo {public static void main(String[] args) { Inter<String> i = new InterImpl();i.show("hello");}}

　　　　第二種情況：實現該接口的時候還不知道是什么類型

//定義一個泛型類public interface Inter<T> {public abstract void show(T t);}//實現該接口的時候還不知道是什么類型的public class InterImpl<T> implements Inter<T> {@Overridepublic void show(T t) {System.out.println(t);}}//測試類public class InterDemo {public static void main(String[] args) {Inter<String> i = new InterImpl<String>();i.show("hello");Inter<Integer> ii = new InterImpl<Integer>();ii.show(100);}}

泛型高級(通配符)

　　泛型通配符<?>

　　　　　表示任意類型，如果沒有明確，那么就是Object以及任意的Java類了

　　? extends E

　　　　　向下限定，E及其子類

　　? super E

　　　　　向上限定，E及其父類

public class GenericDemo {public static void main(String[] args) {// 泛型如果明確的寫的時候，前后必須一致Collection<Object> c1 = new ArrayList<Object>();// Collection<Object> c2 = new ArrayList<Animal>();//報錯// Collection<Object> c3 = new ArrayList<Dog>();//報錯// Collection<Object> c4 = new ArrayList<Cat>();//報錯// ?表示任意的類型都是可以的Collection<?> c5 = new ArrayList<Object>();Collection<?> c6 = new ArrayList<Animal>();Collection<?> c7 = new ArrayList<Dog>();Collection<?> c8 = new ArrayList<Cat>();// ? extends E:向下限定，E及其子類// Collection<? extends Animal> c9 = new ArrayList<Object>();//報錯Collection<? extends Animal> c10 = new ArrayList<Animal>();Collection<? extends Animal> c11 = new ArrayList<Dog>();Collection<? extends Animal> c12 = new ArrayList<Cat>();// ? super E:向上限定，E極其父類Collection<? super Animal> c13 = new ArrayList<Object>();Collection<? super Animal> c14 = new ArrayList<Animal>();// Collection<? super Animal> c15 = new ArrayList<Dog>();//報錯// Collection<? super Animal> c16 = new ArrayList<Cat>();//報錯}}class Animal {}class Dog extends Animal {}class Cat extends Animal {}