java學(xué)習(xí)筆記系列:

java學(xué)習(xí)筆記9--內(nèi)部類總結(jié)

java學(xué)習(xí)筆記8--接口總結(jié)

java學(xué)習(xí)筆記7--抽象類與抽象方法

java學(xué)習(xí)筆記6--類的繼承、Object類

java學(xué)習(xí)筆記5--類的方法

java學(xué)習(xí)筆記4--對(duì)象的初始化與回收

java學(xué)習(xí)筆記3--類與對(duì)象的基礎(chǔ)

java學(xué)習(xí)筆記2--數(shù)據(jù)類型、數(shù)組

java學(xué)習(xí)筆記1--開(kāi)發(fā)環(huán)境平臺(tái)總結(jié)

本文地址：http://m.survivalescaperooms.com/archimedes/p/java-study-note10.html，轉(zhuǎn)載請(qǐng)注明源地址。

集合類中可以存儲(chǔ)各種數(shù)據(jù)，數(shù)據(jù)一旦存入，其類型均會(huì)轉(zhuǎn)化為Object類型。從集合類中取出數(shù)據(jù)時(shí)，一般均需要將Object類型轉(zhuǎn)換回存入之前的實(shí)際類型

Vector v=new Vector();v.add("張三");   //存入字符串String name=(String)v.get(0);  //強(qiáng)制類型轉(zhuǎn)換，OKv.add(new Date());  //存入當(dāng)前時(shí)間對(duì)象，OK // 由于Date類型不能轉(zhuǎn)換為String，下面語(yǔ)句會(huì)在運(yùn)行時(shí)發(fā)生錯(cuò)誤，但這種錯(cuò)誤在編譯時(shí)不會(huì)被檢查出來(lái)String date=(String)v.get(1); //編譯器不會(huì)發(fā)現(xiàn)這里有問(wèn)題

強(qiáng)類型集合

傳統(tǒng)的集合類的實(shí)例中可以存儲(chǔ)任意類型數(shù)據(jù)，這種集合類稱為弱類型集合類。JDK1.5以后，引入了強(qiáng)類型集合類：

• 強(qiáng)類型集合類中，只能存儲(chǔ)指定類型的數(shù)據(jù)

• 在強(qiáng)類型集合類中取出數(shù)據(jù)時(shí)，無(wú)需進(jìn)行類型轉(zhuǎn)換處理，如果數(shù)據(jù)類型不配備，編譯時(shí)會(huì)直接報(bào)錯(cuò)

• 強(qiáng)類型集合并沒(méi)有引入新的類名，只需在定義原有集合對(duì)象時(shí)，用尖括號(hào)(<>)指明其存儲(chǔ)的數(shù)據(jù)類型名稱即可。

舉個(gè)例子：

//下面的向量類的實(shí)例中只能存儲(chǔ)字符串類型數(shù)據(jù)Vector<String> v=new Vector<String>(); v.add("hello"); //加入的是字符串，OKString name=v.get(0); //取出時(shí)，無(wú)需做類型轉(zhuǎn)換,如果想在這種強(qiáng)類型集合中加入日期數(shù)據(jù)，在編譯時(shí)就會(huì)報(bào)告錯(cuò)誤v.add(new Date()); //編譯器會(huì)直接報(bào)告類型不匹配錯(cuò)誤

定義泛型(Generics)類

強(qiáng)類型集合采用了JDK1.5引入的泛型語(yǔ)法。泛型相當(dāng)于類中一種特殊的類型，這種類型的特點(diǎn)是在實(shí)例化該類時(shí)可指定為某個(gè)具體的實(shí)際類型。

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

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

聲明中的泛型1、泛型2等等泛型符號(hào)可以是任意合法的Java標(biāo)識(shí)符。

泛型類的聲明示例

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

泛型類的實(shí)例化

創(chuàng)建泛型類的實(shí)例時(shí)，可以使用一對(duì)尖括號(hào)指定泛型的真正類型

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類型的數(shù)據(jù)        f1.setF(new Boolean(true));        Boolean b = f1.getF();        System.out.println(b);                //f2的setF方法只能接受Integer類型的數(shù)據(jù)        f2.setF(new Integer(10));        Integer i = f2.getF();        System.out.println(i);   }}

實(shí)例化時(shí)的泛型的默認(rèn)類型

泛型類實(shí)例化時(shí)，并不一定要指明泛型對(duì)應(yīng)的實(shí)際類型，此時(shí)會(huì)使用Object作為泛型的默認(rèn)類型

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

編譯時(shí)編譯器會(huì)發(fā)出警告：

Note: Generic.java uses unchecked or unsafe Operations.

Note: Recompile with -Xlint:unchecked for details.

建立類型為泛型類的數(shù)組

如果要建立泛型類的數(shù)組，需要注意new關(guān)鍵字后面不要加入泛型的實(shí)際類型名，如下所示：

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

包含多個(gè)泛型的類定義示例

包含有兩個(gè)泛型定義的類聲明和實(shí)例化：

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

泛型成員的使用

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

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

測(cè)試程序：

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

泛型成員的可用方法

由于泛型類型只有在類實(shí)例化后才能確定，類中的泛型成員只能使用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());    }}

測(cè)試程序：

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

extends關(guān)鍵字用來(lái)指定泛型的上限，在實(shí)例化泛型類時(shí)，為該泛型指定的實(shí)際類型必須是指定類的子類或指定接口的子接口

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;    }}

在限定泛型的類型時(shí)，無(wú)論要限定的是接口或是類，都要使用extends關(guān)鍵詞

測(cè)試?yán)樱?/p>

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

如果不是List的類型，編譯時(shí)就會(huì)發(fā)生錯(cuò)誤：

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

默認(rèn)的泛型限制類型

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

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

相當(dāng)于下面的定義方式:

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是所有類的父類，因此，所有的類型的實(shí)例都可賦值給聲明為Object類型的變量

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

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

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

泛型類實(shí)例之間的不兼容性會(huì)帶來(lái)使用的不便。使用泛型通配符(?)聲明泛型類的變量可以解決這個(gè)問(wèn)題

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

通配符也可以用于方法的參數(shù)類型的聲明，表示該參數(shù)可接受對(duì)應(yīng)泛型類型的任意實(shí)例。

以下類定義中的printCollection方法可以打印任意強(qiáng)類型集合中的內(nèi)容

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

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

Generic<? extends List> f = null;f = new Generic<ArrayList>();    //ok//...f = new Generic<Vector>();    //ok//...//以下語(yǔ)句會(huì)發(fā)生編譯錯(cuò)誤，因?yàn)镠ashMap沒(méi)有實(shí)現(xiàn)List接口f = new Generic<HashMap>();incompatible typesfound : Generic<java.util.HashMap>required: Generic<? extends java.util.List>f = new Generic<HashMap>();

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

還可以使用super關(guān)鍵詞將通配符匹配類型限定為某個(gè)類型及其父類型:

//將f限定為只能代表采用java.sql.Date的父類實(shí)例化的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>();    //錯(cuò)誤，因?yàn)镾tring不是java.sql.Date的父類f = new Generic<String>();

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

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

實(shí)現(xiàn)代碼

}

其中泛型列表為用逗號(hào)分隔的合法Java標(biāo)識(shí)符。

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

泛型方法聲明示例:

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

調(diào)用泛型方法和調(diào)用普通方法沒(méi)有任何不同，只需要傳遞含有具體類型的實(shí)參即可：

泛型方法的調(diào)用示例：

//對(duì)cc中定義的泛型方法fun進(jìn)行調(diào)用測(cè)試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此時(shí)匹配類型String        cc.fun(sa, co);    //fun中的泛型T此時(shí)匹配類型Object   }}

限定泛型方法中泛型類型

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

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

先看一個(gè)泛型類定義

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();    }}

可以使用泛型類而無(wú)需指定具體類型：

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

再看下面的一個(gè)例子：

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);   }}

得到一個(gè)運(yùn)行錯(cuò)誤：

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

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

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

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

再次調(diào)用上面的命令就會(huì)顯示一個(gè)編譯錯(cuò)誤，由于max方法的兩個(gè)參數(shù)必須是相同的類型

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

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;    }}

如果不保留父類中的泛型聲明，則繼承下來(lái)的T1與T2自動(dòng)變?yōu)镺bject類型。建議父類中的泛型聲明在子類中都要保留

繼承時(shí)指定父類的泛型類型

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();    //...}

實(shí)現(xiàn)泛型接口時(shí)，類在定義時(shí)可以不聲明泛型接口中的泛型，此時(shí)接口中的泛型也會(huì)自動(dòng)變?yōu)镺bject類型：

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

泛型接口的實(shí)現(xiàn)

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

實(shí)現(xiàn)泛型接口時(shí)指定泛型類型

在實(shí)現(xiàn)泛型接口時(shí)，也可直接指定接口中的泛型的實(shí)際類型：

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

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

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