java學習筆記系列:

java學習筆記9--內部類總結

java學習筆記8--接口總結

java學習筆記7--抽象類與抽象方法

java學習筆記6--類的繼承、Object類

java學習筆記5--類的方法

java學習筆記4--對象的初始化與回收

java學習筆記3--類與對象的基礎

java學習筆記2--數據類型、數組

java學習筆記1--開發環境平臺總結

本文地址：http://www.49028c.com/archimedes/p/java-study-note10.html，轉載請注明源地址。

集合類中可以存儲各種數據，數據一旦存入，其類型均會轉化為Object類型。從集合類中取出數據時，一般均需要將Object類型轉換回存入之前的實際類型

Vector v=new Vector();v.add("張三");   //存入字符串String name=(String)v.get(0);  //強制類型轉換，OKv.add(new Date());  //存入當前時間對象，OK // 由于Date類型不能轉換為String，下面語句會在運行時發生錯誤，但這種錯誤在編譯時不會被檢查出來String date=(String)v.get(1); //編譯器不會發現這里有問題

強類型集合

傳統的集合類的實例中可以存儲任意類型數據，這種集合類稱為弱類型集合類。JDK1.5以后，引入了強類型集合類：

• 強類型集合類中，只能存儲指定類型的數據

• 在強類型集合類中取出數據時，無需進行類型轉換處理，如果數據類型不配備，編譯時會直接報錯

• 強類型集合并沒有引入新的類名，只需在定義原有集合對象時，用尖括號(<>)指明其存儲的數據類型名稱即可。

舉個例子：

//下面的向量類的實例中只能存儲字符串類型數據Vector<String> v=new Vector<String>(); v.add("hello"); //加入的是字符串，OKString name=v.get(0); //取出時，無需做類型轉換,如果想在這種強類型集合中加入日期數據，在編譯時就會報告錯誤v.add(new Date()); //編譯器會直接報告類型不匹配錯誤

定義泛型(Generics)類

強類型集合采用了JDK1.5引入的泛型語法。泛型相當于類中一種特殊的類型，這種類型的特點是在實例化該類時可指定為某個具體的實際類型。

聲明包含泛型的類的格式如下：

 [訪問修飾符]  class 類名<泛型1,泛型2,&hellip;> {       泛型1  泛型成員1;       泛型2  泛型成員2;       //.... }

聲明中的泛型1、泛型2等等泛型符號可以是任意合法的Java標識符。

泛型類的聲明示例

//此處聲明了一個包含泛型T的泛型類,T代表所有可能的類型，而T的實際類型在Generic類實例化時指定。class Generic<T> {     PRivate T f;  //f為泛型成員     public void setF(T f) {//setF方法的參數類型為泛型T          this.f = f;     }     public T getF() {//getF方法的返回類型為泛型T          return f;     }}

泛型類的實例化

創建泛型類的實例時，可以使用一對尖括號指定泛型的真正類型

public class test {      public static void main(String args[ ]) {         //f1中的泛型T在此指定為Boolean類型        Generic<Boolean> f1 = new Generic<Boolean>();                //f2中的泛型T在此指定為Integer類型        Generic<Integer> f2 = new Generic<Integer>();                //f1的setF方法只能接受Boolean類型的數據        f1.setF(new Boolean(true));        Boolean b = f1.getF();        System.out.println(b);                //f2的setF方法只能接受Integer類型的數據        f2.setF(new Integer(10));        Integer i = f2.getF();        System.out.println(i);   }}

實例化時的泛型的默認類型

泛型類實例化時，并不一定要指明泛型對應的實際類型，此時會使用Object作為泛型的默認類型

Generic f3 = new Generic();f3.setF(new Boolean(false));

編譯時編譯器會發出警告：

Note: Generic.java uses unchecked or unsafe Operations.

Note: Recompile with -Xlint:unchecked for details.

建立類型為泛型類的數組

如果要建立泛型類的數組，需要注意new關鍵字后面不要加入泛型的實際類型名，如下所示：

Generic<String>[] gs;  //聲明泛型類的數組//先對泛型數組進行初始化gs = new Generic[5]; //不要寫成new Generic<String>[5]//再分別為每一個數組元素進行初始化gs[0] = new Generic<String>();//為第一個數組元素賦值//....

包含多個泛型的類定義示例

包含有兩個泛型定義的類聲明和實例化：

class Generic2<T1, T2> {    private T1 f1;    private T2 f2;    //...}//給出泛型T1， T2的實際類型Generic<Integer, Boolean> f = new Generic<Integer, Boolean>();//沒有給出泛型T1， T2的實際類型Generic f1 = new Generic(); //T1， T2將默認為是Object類型

泛型成員的使用

在泛型類中的泛型成員不能直接實例化，其實例必須要通過方法的參數傳遞給泛型成員：

class Generic<T> {    private T[] array;    //此處不能用new T[]實例化array    public void setArray(T[] array) {        this.array = array;    }    public T[] getArray() {        return array;    }}

測試程序：

public class test {      public static void main(String args[ ]) {         String[] strs = {"red", "black", "green"};        Generic<String> f = new Generic<String>();        //向泛型成員array傳遞實際的字符串數組        f.setArray(strs);        //讀取泛型成員array的值，將其賦給字符串數組變量strs        strs = f.getArray();   }}

泛型成員的可用方法

由于泛型類型只有在類實例化后才能確定，類中的泛型成員只能使用Object類型中的方法：

class Generic<T>{    T f;    void setF(T f){ this.f = f; }    //....    void doSome(){        //getClass和toString都是Object中的方法        System.out.println(f.getClass().getName());        System.out.println(f.toString());    }}

測試程序：

public class javatest {      public static void main(String args[ ]) {         String strs = "hello";        Generic<String> f = new Generic<String>();        f.setF(strs);        f.doSome();   }}

extends關鍵字用來指定泛型的上限，在實例化泛型類時，為該泛型指定的實際類型必須是指定類的子類或指定接口的子接口

import java.util.List;public class ListGeneric<T extends List> {    private T list;    public void setList(T list) {        this.list = list;    }    public T getList() {        return list;    }}

在限定泛型的類型時，無論要限定的是接口或是類，都要使用extends關鍵詞

測試例子：

ListGeneric<Vector> f1 = new ListGeneric<Vector>();ListGeneric<ArrayList> f2 = new ListGeneric<ArrayList>();

如果不是List的類型，編譯時就會發生錯誤：

ListGeneric<HashMap> f3 =  new ListGeneric<HashMap>();type parameter java.util.HashMap is not within its boundListGeneric<HashMap> f3 = new ListGeneric<HashMap>();

默認的泛型限制類型

定義泛型類別時，如果只寫以下代碼：

class Generic<T> {    //...}

相當于下面的定義方式:

class Generic<T> extends Object {    //...}

限定泛型上限后的成員可用方法:

class ListGeneric<T extends List>{    private T list;    public void setList(T list) {        this.list = list;    }    public void doSome() {        //ad、get方法都是List接口中定義的方法        list.add(new Integer(0));        System.out.println(list.get(0));    }}

Object是所有類的父類，因此，所有的類型的實例都可賦值給聲明為Object類型的變量

Boolean f1 = new Boolean(true);Integer f2 = new Integer(1);Object f = f1;    //okf = f2;        //ok

在實例化泛型類時，將泛型指定為Object類型卻不存在著和其他類型之間的兼容性：

Generic<Boolean> f1 = new Generic<Boolean>();Generic<Integer> f2 = new Generic<Integer>();Generic<Object> f=f1; //f1和f類型并不兼容,發生編譯錯誤f=f2;  //f2和f類型同樣不兼容，也會發生編譯錯誤 

泛型類實例之間的不兼容性會帶來使用的不便。使用泛型通配符(?)聲明泛型類的變量可以解決這個問題

Generic<Boolean> f1 = new Generic<Boolean>();Generic<Integer> f2 = new Generic<Integer>();Generic<Object> f3 = new Generic<Object>();Generic<?> f;f = f1;    //okf = f2;    //okf = f3;    //ok

通配符也可以用于方法的參數類型的聲明，表示該參數可接受對應泛型類型的任意實例。

以下類定義中的printCollection方法可以打印任意強類型集合中的內容

class test {    //Collection<?>可以匹配任意強類型的集合    static void printCollection(Collection<?> c) {        for(Object o : c)            System.out.println(o);    }}

和限制泛型的上限相似，同樣可以使用extends關鍵字限定通配符匹配類型的上限：

Generic<? extends List> f = null;f = new Generic<ArrayList>();    //ok//...f = new Generic<Vector>();    //ok//...//以下語句會發生編譯錯誤，因為HashMap沒有實現List接口f = new Generic<HashMap>();incompatible typesfound : Generic<java.util.HashMap>required: Generic<? extends java.util.List>f = new Generic<HashMap>();

限定通配符匹配類型的下限

還可以使用super關鍵詞將通配符匹配類型限定為某個類型及其父類型:

//將f限定為只能代表采用java.sql.Date的父類實例化的Generic<? super java.sql.Date> f = null;f = new Generic<java.sql.Date>();    //ok        //OK，java.util.Date是java.sql.Date的父類f = new Generic<java.util.Date>();    //錯誤，因為String不是java.sql.Date的父類f = new Generic<String>();

不僅類可以聲明泛型，類中的方法也可以聲明僅用于自身的泛型，這種方法叫做泛型方法。其定義格式為：

訪問修飾符 <泛型列表> 返回類型 方法名(參數列表){

實現代碼

}

其中泛型列表為用逗號分隔的合法Java標識符。

在泛型列表中聲明的泛型，可用于該方法的返回類型聲明、參數類型聲明和方法代碼中的局部變量的類型聲明。類中其他方法不能使用當前方法聲明的泛型。使用泛型方法可以解決上述的泛型通配符造成的問題

泛型方法聲明示例:

class cc{    /*     方法fun聲明了一個泛型T，該方法將任意類型的數組a中的所有     元素復制到相應的強類型集合c當中而不會導致編譯錯誤。     此處的泛型聲明T僅作用于fun方法的聲明部分和實現代碼部分。     */     public static <T> void fun(T[] a, Collection<T> c){         for(T o : a)             c.add(o);    //不會出現類似通配符的編譯錯誤     }}

調用泛型方法和調用普通方法沒有任何不同，只需要傳遞含有具體類型的實參即可：

泛型方法的調用示例：

//對cc中定義的泛型方法fun進行調用測試public class javatest {      public static void main(String args[ ]) {         String[] sa = new String[100];        Collection<String> cs = new Vector<String>();        Collection<Object> co = new Vector<Object>();                cc.fun(sa, cs);    //fun中的泛型T此時匹配類型String        cc.fun(sa, co);    //fun中的泛型T此時匹配類型Object   }}

限定泛型方法中泛型類型

泛型方法中的聲明的泛型，同樣可以使用extends關鍵字限定其類型的下限：

class cc{  //限定aToC方法中的泛型T必須是實現了序列化接口的類型 　　public static <T extends java.io.Serializable> void fun(T[] a,Collection<T> c){         for(T o : a)             c.add(o);    }}

先看一個泛型類定義

public class GenericStack<E> {    ArrayList<E> list = new ArrayList<E>();    public int getSize() {        return list.size();    }    public E peek() {        return list.get(getSize() - 1);    }    public void push(E o) {        list.add(o);    }    public E pop() {        E o = list.get(getSize() - 1);        list.remove(getSize() - 1);        return o;    }    public boolean isEmpty() {        return list.isEmpty();    }}

可以使用泛型類而無需指定具體類型：

GenericStack stack = new GenericStack();//大體等價于于下面的語句GenericStack<Object> stack = new GenericStack<Object>();

再看下面的一個例子：

class Max {    public static Comparable max(Comparable o1, Comparable o2) {        if(o1.compareTo(o2) > 0)            return o1;        return o2;    }}public class javatest {      public static void main(String args[]) {         Max.max("welcome", 12);   }}

得到一個運行錯誤：

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

結論：原始類型是不安全的，盡量使用泛型類型

一個更好的編寫max方法的方式是使用泛型：

class Max {    public static <E extends Comparable<E>> E max(E o1, E o2) {        if(o1.compareTo(o2) > 0)            return o1;        return o2;    }}

再次調用上面的命令就會顯示一個編譯錯誤，由于max方法的兩個參數必須是相同的類型

繼承時如需保留父類泛型，需要在聲明時加入父類泛型

class subGeneric<T1, T2, T3> extends Generic<T1, T2> {    private T3 f3;    public void setF3(T3 f3) {        this.f3 = f3;    }    public T3 getF3() {        return f3;    }}

如果不保留父類中的泛型聲明，則繼承下來的T1與T2自動變為Object類型。建議父類中的泛型聲明在子類中都要保留

繼承時指定父類的泛型類型

public class SubGeneric<T3> extends Generic<String, Object> {    private T3 f3;    public void setF3(T3 f3) {        this.f3 = f3;    }    public T3 getF3() {        return f3;    }}

接口也可包含泛型的聲明:

interface I<T1, T2> {    T1 getT1();    T2 getT2();    //...}

實現泛型接口時，類在定義時可以不聲明泛型接口中的泛型，此時接口中的泛型也會自動變為Object類型：

class IC implements I {    public Object getT1() { }    public Object getT2() { }    //...}

泛型接口的實現

class IC<T1, T2> implements I<T1, T2> {    public T1 getT1() { }    public T2 getT2() { }    //...}I<String, Integer> i = new IC<String, Integer>();

實現泛型接口時指定泛型類型

在實現泛型接口時，也可直接指定接口中的泛型的實際類型：

interface I<T1, T2> {    T1 getT1();    T2 getT2();    //...}//實現接口I時，直接指定泛型T1、T2的類型class IC implements I<String, Integer> {    //由于指定接口I中T1類型為String，getT1返回類型必須為String    public String getT1() { }    //由于指定接口I中T2類型為Integer，getT2返回類型必須為Integer    public Integer getT2() { }    //...}

由于枚舉類型不能直接實例化，所以枚舉的定義中不能含有泛型的聲明，但枚舉中可包含泛型方法的定義。

public enum TrafficLight{  Red,Amber,Green;  private int duration;  public static <T> void avgDuration(Collection<T> carType){     //....  }  //....}