對(dui)java的(de)泛型(xing)特性(xing)的(de)了解僅限于表面的(de)淺(qian)淺(qian)一(yi)層，直到在學習設計模式時(shi)發現有(you)不了解的(de)用法(fa)，才想起詳細的(de)記(ji)錄一(yi)下。

本文參考java 泛型(xing)詳解、Java中的(de)泛型(xing)方(fang)法(fa)、 java泛型(xing)詳解

泛(fan)型，即“參數化類(lei)型”。一提到參數，最(zui)熟悉(xi)的就(jiu)是(shi)定(ding)義方(fang)法(fa)時有形參，然后調用此方(fang)法(fa)時傳遞實參。那(nei)么參數化類(lei)型怎么理(li)解呢(ni)？

顧名思義，就是將(jiang)類(lei)(lei)型由(you)原來的具體的類(lei)(lei)型參(can)數化，類(lei)(lei)似于方法中的變量參(can)數，此時類(lei)(lei)型也(ye)定(ding)義成參(can)數形式（可以(yi)稱之(zhi)為類(lei)(lei)型形參(can)），

然后在使用(yong)/調(diao)用(yong)時(shi)傳入(ru)具體的(de)(de)(de)類(lei)(lei)型(xing)(xing)(xing)（類(lei)(lei)型(xing)(xing)(xing)實(shi)參）。

泛(fan)(fan)(fan)型(xing)(xing)(xing)的(de)(de)(de)本質(zhi)是(shi)為了(le)參數化類(lei)(lei)型(xing)(xing)(xing)（在不(bu)創建新(xin)的(de)(de)(de)類(lei)(lei)型(xing)(xing)(xing)的(de)(de)(de)情況下，通(tong)過泛(fan)(fan)(fan)型(xing)(xing)(xing)指定(ding)的(de)(de)(de)不(bu)同類(lei)(lei)型(xing)(xing)(xing)來控制(zhi)形參具體限制(zhi)的(de)(de)(de)類(lei)(lei)型(xing)(xing)(xing)）。也就是(shi)說在泛(fan)(fan)(fan)型(xing)(xing)(xing)使用(yong)過程中，

操作(zuo)的(de)數據類(lei)型(xing)被(bei)指定為(wei)一(yi)個參(can)數，這(zhe)種參(can)數類(lei)型(xing)可以(yi)用在類(lei)、接口(kou)和方法中，分別被(bei)稱為(wei)泛(fan)型(xing)類(lei)、泛(fan)型(xing)接口(kou)、泛(fan)型(xing)方法。

List arrayList = new ArrayList();
arrayList.add("aaaa");
arrayList.add(100);

for(int i = 0; i< arrayList.size();i++){
    String item = (String)arrayList.get(i);
    Log.d("泛型測試","item = " + item);
}

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

List<String> arrayList = new ArrayList<String>();
...
//arrayList.add(100); 在編(bian)譯階段(duan)，編(bian)譯器就會(hui)報錯

List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();

Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();

if(classStringArrayList.equals(classIntegerArrayList)){
    Log.d("泛型測試","類型相同");
}

class 類名稱 <泛型標識：可以隨便寫任意標識號，標識指定的泛型的類型>{
  private 泛型標識 /*（成(cheng)員變量(liang)類(lei)型）*/ var; 
  .....

  }
}

//此處T可以隨便寫(xie)為任意標識(shi)，常(chang)見的如T、E、K、V等形式的參數常(chang)用于(yu)表示(shi)泛型
//在實(shi)例化泛型類時，必須(xu)指定T的具(ju)體類型
public class Generic<T>{ 
    //key這個成員變量的類(lei)(lei)型為T,T的類(lei)(lei)型由外部指(zhi)定(ding)  
    private T key;

    public Generic(T key) { //泛型(xing)(xing)構造方法(fa)形參(can)key的(de)(de)類(lei)型(xing)(xing)也為T，T的(de)(de)類(lei)型(xing)(xing)由外部指定
        this.key = key;
    }

    public T getKey(){ //泛(fan)型(xing)方法getKey的(de)(de)返(fan)回值(zhi)類型(xing)為T，T的(de)(de)類型(xing)由外部指(zhi)定(ding)
        return key;
    }
}

//泛型的(de)類(lei)型參數(shu)只能是(shi)類(lei)類(lei)型（包括自(zi)定義類(lei)），不能是(shi)簡單類(lei)型
//傳入的實參類型需與泛型的類型參數(shu)類型相(xiang)同，即為(wei)Integer.
Generic<Integer> genericInteger = new Generic<Integer>(123456);

//傳入的(de)實參(can)類(lei)型需與泛型的(de)類(lei)型參(can)數類(lei)型相同，即為String.
Generic<String> genericString = new Generic<String>("key_vlaue");
Log.d("泛型測試","key is " + genericInteger.getKey());
Log.d("泛型測試","key is " + genericString.getKey());

12-27 09:20:04.432 13063-13063/? D/泛型測(ce)試: key is 123456
12-27 09:20:04.432 13063-13063/? D/泛型測(ce)試: key is key_vlaue

Generic generic = new Generic("111111");
Generic generic1 = new Generic(4444);
Generic generic2 = new Generic(55.55);
Generic generic3 = new Generic(false);

Log.d("泛型測試","key is " + generic.getKey());
Log.d("泛型測試","key is " + generic1.getKey());
Log.d("泛型測試","key is " + generic2.getKey());
Log.d("泛型測試","key is " + generic3.getKey());

D/泛型測試: key is 111111
D/泛型測試: key is 4444
D/泛型測試: key is 55.55
D/泛型測試: key is false

//定義一個泛型接口(kou)
public interface Generator<T> {
    public T next();
}

/**
 * 未傳入泛(fan)型(xing)實參(can)時，與泛(fan)型(xing)類的(de)定義相同，在(zai)聲(sheng)(sheng)明(ming)類的(de)時候(hou)，需將泛(fan)型(xing)的(de)聲(sheng)(sheng)明(ming)也一起加到類中(zhong)
 * 即(ji)：class FruitGenerator<T> implements Generator<T>{
 * 如(ru)果不(bu)聲(sheng)(sheng)明(ming)泛(fan)型(xing)，如(ru)：class FruitGenerator implements Generator<T>，編譯器(qi)會(hui)報錯："Unknown class"
 */
class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}

/**
 * 傳(chuan)入(ru)(ru)泛(fan)型(xing)(xing)(xing)實(shi)參(can)時(shi)：
 * 定義一個(ge)生產器(qi)實(shi)現(xian)這個(ge)接(jie)口(kou)(kou),雖然我們只(zhi)創建了一個(ge)泛(fan)型(xing)(xing)(xing)接(jie)口(kou)(kou)Generator<T>
 * 但(dan)是我們可以為T傳(chuan)入(ru)(ru)無數個(ge)實(shi)參(can)，形成(cheng)無數種類(lei)型(xing)(xing)(xing)的(de)(de)(de)Generator接(jie)口(kou)(kou)。
 * 在實(shi)現(xian)類(lei)實(shi)現(xian)泛(fan)型(xing)(xing)(xing)接(jie)口(kou)(kou)時(shi)，如(ru)已將泛(fan)型(xing)(xing)(xing)類(lei)型(xing)(xing)(xing)傳(chuan)入(ru)(ru)實(shi)參(can)類(lei)型(xing)(xing)(xing)，則所有使用泛(fan)型(xing)(xing)(xing)的(de)(de)(de)地方都(dou)要替換(huan)成(cheng)傳(chuan)入(ru)(ru)的(de)(de)(de)實(shi)參(can)類(lei)型(xing)(xing)(xing)
 * 即：Generator<T>，public T next();中的(de)(de)(de)的(de)(de)(de)T都(dou)要替換(huan)成(cheng)傳(chuan)入(ru)(ru)的(de)(de)(de)String類(lei)型(xing)(xing)(xing)。
 */
public class FruitGenerator implements Generator<String> {

    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

public void showKeyValue1(Generic<Number> obj){
    Log.d("泛型測試","key value is " + obj.getKey());
}

Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);

showKeyValue(gNumber);

// showKeyValue這個方法編譯器會為我們報錯：Generic<java.lang.Integer> 
// cannot be applied to Generic<java.lang.Number>
// showKeyValue(gInteger);

public void showKeyValue1(Generic<?> obj){
    Log.d("泛型測試","key value is " + obj.getKey());
}

尤其是我們見(jian)到的大(da)多數泛型(xing)類中的成員方(fang)法(fa)也(ye)都使用了泛型(xing)，有(you)的甚至泛型(xing)類中也(ye)包含(han)著泛型(xing)方(fang)法(fa)，這樣在(zai)初學者中非常容(rong)易將泛型(xing)方(fang)法(fa)理解錯(cuo)了。

/**
 * 泛(fan)型方法的基本(ben)介紹
 * @param tClass 傳入的泛型實參
 * @return T 返回(hui)值為(wei)(wei)T類(lei)(lei)(lei)型(xing)(xing)
 * 說明(ming)(ming)：
 *     1）public 與(yu)(yu) 返回(hui)值中(zhong)(zhong)間<T>非常(chang)重(zhong)要(yao)，可(ke)以(yi)理解為(wei)(wei)聲明(ming)(ming)此(ci)方(fang)法為(wei)(wei)泛(fan)(fan)(fan)型(xing)(xing)方(fang)法。
 *     2）只有聲明(ming)(ming)了<T>的(de)方(fang)法才(cai)是(shi)泛(fan)(fan)(fan)型(xing)(xing)方(fang)法，泛(fan)(fan)(fan)型(xing)(xing)類(lei)(lei)(lei)中(zhong)(zhong)的(de)使用了泛(fan)(fan)(fan)型(xing)(xing)的(de)成員方(fang)法并不是(shi)泛(fan)(fan)(fan)型(xing)(xing)方(fang)法。
 *     3）<T>表明(ming)(ming)該方(fang)法將使用泛(fan)(fan)(fan)型(xing)(xing)類(lei)(lei)(lei)型(xing)(xing)T，此(ci)時(shi)才(cai)可(ke)以(yi)在方(fang)法中(zhong)(zhong)使用泛(fan)(fan)(fan)型(xing)(xing)類(lei)(lei)(lei)型(xing)(xing)T。
 *     4）與(yu)(yu)泛(fan)(fan)(fan)型(xing)(xing)類(lei)(lei)(lei)的(de)定義一樣，此(ci)處T可(ke)以(yi)隨(sui)便寫為(wei)(wei)任意標識，常(chang)見的(de)如T、E、K、V等(deng)形式的(de)參數(shu)常(chang)用于(yu)表示泛(fan)(fan)(fan)型(xing)(xing)。
 */
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}

Object obj = genericMethod(Class.forName("com.test.test"));

public class GenericTest {
   //這個(ge)類(lei)是個(ge)泛型(xing)類(lei)，在上面已(yi)經介紹過
   public class Generic<T>{     
        private T key;

        public Generic(T key) {
            this.key = key;
        }

        //我想說的其實是(shi)(shi)這(zhe)個，雖然在方(fang)法中使用了泛型，但是(shi)(shi)這(zhe)并不(bu)是(shi)(shi)一(yi)個泛型方(fang)法。
        //這只是類中一個普通的(de)成員方法，只不(bu)過他的(de)返回(hui)值是在聲(sheng)明泛型類已經(jing)聲(sheng)明過的(de)泛型。
        //所以在(zai)這個方(fang)法(fa)中才可以繼續使用(yong) T 這個泛型。
        public T getKey(){
            return key;
        }

        /**
         * 這個方法顯然是有問題的(de)，在編譯器會給我(wo)們(men)提(ti)示這樣(yang)的(de)錯誤信息(xi)"cannot reslove symbol E"
         * 因為在類的(de)聲明(ming)中(zhong)并未聲明(ming)泛型E，所(suo)以在使用(yong)E做形參和返回值類型時，編譯器會無法識(shi)別(bie)。
        public E setKey(E key){
             this.key = keu
        }
        */
    }

    /** 
     * 這(zhe)(zhe)(zhe)才(cai)是一(yi)個(ge)真正的泛(fan)(fan)(fan)型(xing)方法。
     * 首先在public與返回(hui)值之間的<T>必不(bu)可少，這(zhe)(zhe)(zhe)表明(ming)這(zhe)(zhe)(zhe)是一(yi)個(ge)泛(fan)(fan)(fan)型(xing)方法，并且聲明(ming)了一(yi)個(ge)泛(fan)(fan)(fan)型(xing)T
     * 這(zhe)(zhe)(zhe)個(ge)T可以出現在這(zhe)(zhe)(zhe)個(ge)泛(fan)(fan)(fan)型(xing)方法的任意位置.
     * 泛(fan)(fan)(fan)型(xing)的數量也可以為任意多個(ge) 
     *    如：public <T,K> K showKeyName(Generic<T> container){
     *        ...
     *        }
     */
    public <T> T showKeyName(Generic<T> container){
        System.out.println("container key :" + container.getKey());
        //當然這個例(li)子舉的不太合適，只是為了(le)說明泛型(xing)方法的特性(xing)。
        T test = container.getKey();
        return test;
    }

    //這也不是(shi)(shi)一個泛型方法(fa)，這就是(shi)(shi)一個普(pu)通(tong)的方法(fa)，只是(shi)(shi)使用了Generic<Number>這個泛型類做形參而已。
    public void showKeyValue1(Generic<Number> obj){
        Log.d("泛型測試","key value is " + obj.getKey());
    }

    //這(zhe)也(ye)不是一個泛型方法，這(zhe)也(ye)是一個普(pu)通(tong)的方法，只不過使用了泛型通(tong)配符?
    //同時這也印證了泛型通配符(fu)章節所(suo)描述的，?是(shi)一(yi)種類(lei)型實參，可以看做為Number等所(suo)有類(lei)的父類(lei)
    public void showKeyValue2(Generic<?> obj){
        Log.d("泛型測試","key value is " + obj.getKey());
    }

     /**
     * 這個(ge)方(fang)法是有問題的(de)，編譯器會(hui)為我(wo)們(men)(men)提示錯誤信息："UnKnown class 'E' "
     * 雖然(ran)我(wo)們(men)(men)聲(sheng)(sheng)明(ming)了<T>,也表明(ming)了這是一個(ge)可以處理泛(fan)型(xing)(xing)的(de)類型(xing)(xing)的(de)泛(fan)型(xing)(xing)方(fang)法。
     * 但是只聲(sheng)(sheng)明(ming)了泛(fan)型(xing)(xing)類型(xing)(xing)T，并未聲(sheng)(sheng)明(ming)泛(fan)型(xing)(xing)類型(xing)(xing)E，因此(ci)編譯器并不(bu)知(zhi)道該如何(he)處理E這個(ge)類型(xing)(xing)。
    public <T> T showKeyName(Generic<E> container){
        ...
    }  
    */

    /**
     * 這個方(fang)法(fa)也是有問題的，編(bian)譯(yi)器會為我們提示(shi)錯(cuo)誤信息："UnKnown class 'T' "
     * 對于編(bian)譯(yi)器來說T這個類(lei)型(xing)并未項目中聲(sheng)(sheng)明(ming)過，因(yin)此編(bian)譯(yi)也不知道該如何編(bian)譯(yi)這個類(lei)。
     * 所以(yi)這也不是一(yi)個正確的泛型(xing)方(fang)法(fa)聲(sheng)(sheng)明(ming)。
    public void showkey(T genericObj){

    }
    */

    public static void main(String[] args) {


    }
}

public class GenericFruit {
    class Fruit{
        @Override
        public String toString() {
            return "fruit";
        }
    }

    class Apple extends Fruit{
        @Override
        public String toString() {
            return "apple";
        }
    }

    class Person{
        @Override
        public String toString() {
            return "Person";
        }
    }

    class GenerateTest<T>{
        public void show_1(T t){
            System.out.println(t.toString());
        }

        //在泛(fan)型(xing)類(lei)(lei)中(zhong)聲(sheng)明了一個泛(fan)型(xing)方法，使用泛(fan)型(xing)E，這種泛(fan)型(xing)E可(ke)以(yi)為任意類(lei)(lei)型(xing)。可(ke)以(yi)類(lei)(lei)型(xing)與T相同，也可(ke)以(yi)不同。
        //由于泛(fan)(fan)型(xing)(xing)方法在(zai)聲(sheng)明的時候會聲(sheng)明泛(fan)(fan)型(xing)(xing)<E>，因此(ci)即使在(zai)泛(fan)(fan)型(xing)(xing)類中并未聲(sheng)明泛(fan)(fan)型(xing)(xing)，編譯(yi)器也能夠正確識(shi)別泛(fan)(fan)型(xing)(xing)方法中識(shi)別的泛(fan)(fan)型(xing)(xing)。
        public <E> void show_3(E t){
            System.out.println(t.toString());
        }

        //在泛型(xing)類(lei)中聲明(ming)了一(yi)(yi)個泛型(xing)方法，使用(yong)泛型(xing)T，注意(yi)這(zhe)個T是(shi)一(yi)(yi)種全新的類(lei)型(xing)，可以與(yu)泛型(xing)類(lei)中聲明(ming)的T不是(shi)同一(yi)(yi)種類(lei)型(xing)。
        public <T> void show_2(T t){
            System.out.println(t.toString());
        }
    }

    public static void main(String[] args) {
        Apple apple = new Apple();
        Person person = new Person();

        GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
        //apple是(shi)Fruit的子類，所以這里(li)可(ke)以
        generateTest.show_1(apple);
        //編(bian)譯器(qi)會報錯(cuo)，因為泛型類型實(shi)參指(zhi)定的是Fruit，而傳入的實(shi)參類是Person
        //generateTest.show_1(person);

        //使(shi)用這兩個方法都(dou)可以(yi)成功
        generateTest.show_2(apple);
        generateTest.show_2(person);

        //使用這兩個方法(fa)也都(dou)可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);
    }
}

public <T> void printMsg( T... args){
    for(T t : args){
        Log.d("泛型測試","t is " + t);
    }
}

printMsg("111",222,"aaaa","2323.4",55.55);

public class StaticGenerator<T> {
    ....
    ....
    /**
     * 如果在類中定義使用(yong)泛(fan)(fan)(fan)型(xing)的(de)靜(jing)態方(fang)法(fa)，需要添加(jia)額外的(de)泛(fan)(fan)(fan)型(xing)聲(sheng)明（將這個方(fang)法(fa)定義成泛(fan)(fan)(fan)型(xing)方(fang)法(fa)）
     * 即使靜(jing)態方(fang)法(fa)要使用(yong)泛(fan)(fan)(fan)型(xing)類中已經聲(sheng)明過的(de)泛(fan)(fan)(fan)型(xing)也(ye)不(bu)可以(yi)。
     * 如：public static void show(T t){..},此時編譯器(qi)會(hui)提示錯(cuo)誤信息：
          "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t){

    }
}

無論何時(shi)，如果你(ni)能做到，你(ni)就(jiu)(jiu)該盡(jin)量使(shi)用泛(fan)型(xing)方法(fa)。也就(jiu)(jiu)是說，如果使(shi)用泛(fan)型(xing)方法(fa)將整個(ge)類(lei)泛(fan)型(xing)化，

那么就(jiu)應該使用泛(fan)型方(fang)法(fa)(fa)。另外對于一個static的(de)方(fang)法(fa)(fa)而已(yi)，無法(fa)(fa)訪問泛(fan)型類型的(de)參數。

所以如果static方(fang)法(fa)要使(shi)用泛(fan)型能(neng)力，就必須使(shi)其成為泛(fan)型方(fang)法(fa)。

public void showKeyValue1(Generic<? extends Number> obj){
    Log.d("泛型測試","key value is " + obj.getKey());
}

Generic<String> generic1 = new Generic<String>("11111");
Generic<Integer> generic2 = new Generic<Integer>(2222);
Generic<Float> generic3 = new Generic<Float>(2.4f);
Generic<Double> generic4 = new Generic<Double>(2.56);

//這一行代(dai)碼(ma)編譯器會(hui)提示錯誤，因(yin)為(wei)String類(lei)(lei)型并(bing)不是(shi)Number類(lei)(lei)型的子類(lei)(lei)
//showKeyValue1(generic1);

showKeyValue1(generic2);
showKeyValue1(generic3);
showKeyValue1(generic4);

public class Generic<T extends Number>{
    private T key;

    public Generic(T key) {
        this.key = key;
    }

    public T getKey(){
        return key;
    }
}

//這一(yi)行代碼也會報錯，因為String不是Number的子類(lei)
Generic<String> generic1 = new Generic<String>("11111");

//在(zai)(zai)泛型(xing)方(fang)法中添加上下邊界(jie)限制的(de)(de)時(shi)候，必須在(zai)(zai)權限聲明(ming)(ming)與返回(hui)值之間(jian)的(de)(de)<T>上添加上下邊界(jie)，即(ji)在(zai)(zai)泛型(xing)聲明(ming)(ming)的(de)(de)時(shi)候添加
//public <T> T showKeyName(Generic<T extends Number> container)，編譯器會報錯："Unexpected bound"
public <T extends Number> T showKeyName(Generic<T> container){
    System.out.println("container key :" + container.getKey());
    T test = container.getKey();
    return test;
}

List<String>[] ls = new ArrayList<String>[10];  

List<?>[] ls = new ArrayList<?>[10]; 

List<String>[] ls = new ArrayList[10];

List<String>[] lsa = new List<String>[10]; // Not really allowed.    
Object o = lsa;    
Object[] oa = (Object[]) o;    
List<Integer> li = new ArrayList<Integer>();    
li.add(new Integer(3));    
oa[1] = li; // Unsound, but passes run time store check    
String s = lsa[1].get(0); // Run-time error: ClassCastException.

這種情況下，由于JVM泛型的擦除機制，在運行時JVM是不知道泛型信息的，所以可以給oa[1]賦上一個ArrayList而不會出現異常，

但是在取出數據的時候卻要做一次類型轉換，所以就會出現ClassCastException，如果可以進行泛型數組的聲明，

上面說的這種情況在編譯期將不會出現任何的警告和錯誤，只有在運行時才會出錯。

而對泛型數組的聲明進行限制，對于這樣的情況，可以在編譯期提示代碼有類型安全問題，比沒有任何提示要強很多。

List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type.    
Object o = lsa;    
Object[] oa = (Object[]) o;    
List<Integer> li = new ArrayList<Integer>();    
li.add(new Integer(3));    
oa[1] = li; // Correct.    
Integer i = (Integer) lsa[1].get(0); // OK