1. 泛型概述

泛型（Generic type 或者 generics）是對 Java 語言的類型系統(tǒng)的一種擴展，以支持創(chuàng)建可以按類型進行參數(shù)化的類衷模。可以把類型參數(shù)看作是使用參數(shù)化類型時指定的類型的一個占位符蒲赂，就像方法的形式參數(shù)是運行時傳遞的值的占位符一樣阱冶。

泛型是Java SE 1.5的新特性，泛型的本質(zhì)是參數(shù)化類型凳宙，也就是說所操作的數(shù)據(jù)類型被指定為一個參數(shù)熙揍。這種參數(shù)類型可以用在類、接口和方法的創(chuàng)建中氏涩，分別稱為泛型類届囚、泛型接口、泛型方法是尖。 Java語言引入泛型的好處是安全簡單意系。

在Java SE 1.5之前，沒有泛型的情況的下饺汹，通過對類型Object的引用來實現(xiàn)參數(shù)的“任意化”蛔添，“任意化”帶來的缺點是要做顯式的強制類型轉(zhuǎn)換，而這種轉(zhuǎn)換是要求開發(fā)者對實際參數(shù)類型可以預(yù)知的情況下進行的兜辞。對于強制類型轉(zhuǎn)換錯誤的情況迎瞧，編譯器可能不提示錯誤，在運行的時候才出現(xiàn)異常逸吵，這是一個安全隱患凶硅。

泛型的好處是在編譯的時候檢查類型安全，并且所有的強制轉(zhuǎn)換都是自動和隱式的扫皱，以提高代碼的重用率足绅。

可以在集合框架（Collection framework）中看到泛型的動機。例如韩脑，Map 類允許您向一個 Map添加任意類的對象氢妈，即使最常見的情況是在給定映射（map）中保存某個特定類型（比如 String）的對象。

因為 Map.get() 被定義為返回 Object段多，所以一般必須將 Map.get() 的結(jié)果強制類型轉(zhuǎn)換為期望的類型首量，如下面的代碼所示：

  Map m = new HashMap();
  m.put("key", "blarg");
  String s = (String) m.get("key");

要讓程序通過編譯，必須將 get() 的結(jié)果強制類型轉(zhuǎn)換為 String，并且希望結(jié)果真的是一個 String加缘。但是有可能某人已經(jīng)在該映射中保存了不是 String 的東西粥航，這樣的話，上面的代碼將會拋出 ClassCastException生百。

理想情況下，您可能會得出這樣一個觀點柄延，即 m 是一個 Map蚀浆，它將 String 鍵映射到 String 值。這可以讓您消除代碼中的強制類型轉(zhuǎn)換搜吧，同時獲得一個附加的類型檢查層市俊，該檢查層可以防止有人將錯誤類型的鍵或值保存在集合中。這就是泛型所做的工作滤奈。

package cn.itcast_01;

import java.util.ArrayList;
import java.util.Iterator;

/*
 * ArrayList存儲字符串并遍歷
 * 
 * 我們按照正常的寫法來寫這個程序摆昧， 結(jié)果確出錯了。
 * 為什么呢?
 *      因為我們開始存儲的時候蜒程，存儲了String和Integer兩種類型的數(shù)據(jù)绅你。
 *      而在遍歷的時候，我們把它們都當(dāng)作String類型處理的昭躺，做了轉(zhuǎn)換忌锯，所以就報錯了。
 * 但是呢领炫，它在編譯期間卻沒有告訴我們偶垮。
 * 所以，我就覺得這個設(shè)計的不好帝洪。
 * 回想一下似舵，我們的數(shù)組
 *      String[] strArray = new String[3];
 *      strArray[0] = "hello";
 *      strArray[1] = "world";
 *      strArray[2] = 10;
 * 集合也模仿著數(shù)組的這種做法，在創(chuàng)建對象的時候明確元素的數(shù)據(jù)類型葱峡。這樣就不會在有問題了砚哗。
 * 而這種技術(shù)被稱為：泛型。
 * 
 * 泛型：是一種把類型明確的工作推遲到創(chuàng)建對象或者調(diào)用方法的時候才去明確的特殊的類型族沃。參數(shù)化類型频祝，把類型當(dāng)作參數(shù)一樣的傳遞。
 * 格式：
 *      <數(shù)據(jù)類型>
 *      此處的數(shù)據(jù)類型只能是引用類型脆淹。
 * 好處：
 *      A:把運行時期的問題提前到了編譯期間
 *      B:避免了強制類型轉(zhuǎn)換
 *      C:優(yōu)化了程序設(shè)計常空，解決了黃色警告線
 */
public class GenericDemo {
    public static void main(String[] args) {
        // 創(chuàng)建
        ArrayList<String> array = new ArrayList<String>();

        // 添加元素
        array.add("hello");
        array.add("world");
        array.add("java");
        // array.add(new Integer(100));
        //array.add(10); // JDK5以后的自動裝箱
        // 等價于：array.add(Integer.valueOf(10));

        // 遍歷
        Iterator<String> it = array.iterator();
        while (it.hasNext()) {
            // ClassCastException
            // String s = (String) it.next();
            String s = it.next();
            System.out.println(s);
        }

        // 看下面這個代碼
        // String[] strArray = new String[3];
        // strArray[0] = "hello";
        // strArray[1] = "world";
        // strArray[2] = 10;
    }
}

2. 泛型的好處

Java 語言中引入泛型是一個較大的功能增強。不僅語言盖溺、類型系統(tǒng)和編譯器有了較大的變化漓糙，以支持泛型，而且類庫也進行了大翻修烘嘱，所以許多重要的類昆禽，比如集合框架蝗蛙，都已經(jīng)成為泛型化的了。這帶來了很多好處：

2.1 類型安全

泛型的主要目標(biāo)是提高 Java 程序的類型安全醉鳖。通過知道使用泛型定義的變量的類型限制捡硅，編譯器可以在一個高得多的程度上驗證類型假設(shè)。沒有泛型盗棵，這些假設(shè)就只存在于程序員的頭腦中（或者如果幸運的話壮韭，還存在于代碼注釋中）。

Java 程序中的一種流行技術(shù)是定義這樣的集合纹因，即它的元素或鍵是公共類型的喷屋，比如“String 列表”或者“String 到 String 的映射”。通過在變量聲明中捕獲這一附加的類型信息瞭恰，泛型允許編譯器實施這些附加的類型約束屯曹。類型錯誤現(xiàn)在就可以在編譯時被捕獲了，而不是在運行時當(dāng)作 ClassCastException 展示出來惊畏。將類型檢查從運行時挪到編譯時有助于您更容易找到錯誤恶耽，并可提高程序的可靠性。

2.2 消除強制類型轉(zhuǎn)換

泛型的一個附帶好處是颜启，消除源代碼中的許多強制類型轉(zhuǎn)換驳棱。這使得代碼更加可讀，并且減少了出錯機會农曲。
盡管減少強制類型轉(zhuǎn)換可以降低使用泛型類的代碼的羅嗦程度社搅，但是聲明泛型變量會帶來相應(yīng)的羅嗦。

2.3 優(yōu)化了程序設(shè)計乳规，解決了黃色警告線

3. 泛型的應(yīng)用

3.1 泛型的內(nèi)部原理

泛型是提供給javac編譯器使用的形葬，可以限定集合中的輸入類型，讓編譯器擋住源程序中的非法輸入暮的。但是笙以，編譯器編譯帶類型說明的集合時會去除掉“類型”信息，目的就是使程序運行效率不受影響冻辩。因此猖腕，對于參數(shù)化的泛型類型，getClass()方法的返回值和原始類型完全一樣恨闪。

package com.itheima.day2;

import java.util.ArrayList;

public class GenericTest {
      
       public static void main(String[] args) {
            ArrayList<String> collection1 = new ArrayList<String>();
            ArrayList collection2 = new ArrayList();
            System. out.println(collection1.getClass() == collection2.getClass());
             //結(jié)果：true
      }
}

由于編譯生成的字節(jié)碼會去掉泛型的類型信息倘感，只要能跳過編譯器，就可以往某個泛型集合中加入其它類型的數(shù)據(jù)咙咽，例如老玛，用反射得到集合，再調(diào)用其add方法即可。

package com.itheima.day2;

import java.util.ArrayList;

public class GenericTest {
      
       public static void main(String[] args) throws Exception {
            ArrayList<Integer> collection1 = new ArrayList<Integer>();
            collection1.getClass().getMethod( "add",Object.class).invoke(collection1, "abc");
            System. out.println(collection1.get(0));
      }
}

ArrayList<E>類定義和ArrayList<Integer>類引用中涉及如下術(shù)語：

• 整個稱為ArrayList<E>泛型類型
• ArrayList<E>中的E稱為類型變量或類型參數(shù)
• 整個ArrayList<Integer>稱為參數(shù)化的類型
• ArrayList<Integer>中的Integer稱為類型參數(shù)的實例或?qū)嶋H類型參數(shù)
• ArrayList<Integer>中的<>念著typeof
• ArrayList稱為原始類型

參數(shù)化類型與原始類型的兼容性：參數(shù)化類型可以引用一個原始類型的對象蜡豹，編譯報告警告麸粮，例如

Collection<String> c = new Vector();//考慮到對以前代碼的兼容性，編譯器是可以通過的

原始類型可以引用一個參數(shù)化類型的對象镜廉，編譯報告警告弄诲，例如

Collection c = new Vector<String>();//原來的方法接受一個集合參數(shù)，新的類型也要能傳進去

參數(shù)化類型不考慮類型參數(shù)的繼承關(guān)系：

Vector<String> v = new Vector<Object>(); //錯誤!不寫<Object>沒錯娇唯，寫了就是明知故犯
Vector<Object> v = new Vector<String>(); //也錯誤!

注意：

假設(shè)Vector<String> v = new Vector<Object>();可以的話威根，那么以后從v中取出的對象當(dāng)作String用，而v實際指向的對象中可以加入任意的類型對象视乐；

假設(shè)Vector<Object> v = new Vector<String>();可以的話，那么以后可以向v中加入任意的類型對象敢茁，而v實際指向的集合中只能裝String類型的對象佑淀。

編譯器不允許創(chuàng)建泛型變量的數(shù)組。即在創(chuàng)建數(shù)組實例時彰檬，數(shù)組的元素不能使用參數(shù)化的類型伸刃。

例如，下面語句有錯誤：

Vector<Integer> vectorList[] = new Vector<Integer>[10];

思考題：

下面的代碼會報錯誤嗎逢倍？

Vector v1 = new Vector<String>();
Vector<Object> v = v1;

答案：編譯的時候是不會報錯的捧颅，因為編譯器是一行一行按照語法檢查代碼的，因此不會出錯较雕。

4. 泛型類

把泛型定義在類上碉哑，格式:public class 類名<泛型類型1,…>，注意:泛型類型必須是引用類型

package cn.itcast_04;

/*
 * 泛型類的測試
 */
public class ObjectToolDemo {
    public static void main(String[] args) {
        // ObjectTool ot = new ObjectTool();
        //
        // ot.setObj(new String("風(fēng)清揚"));
        // String s = (String) ot.getObj();
        // System.out.println("姓名是：" + s);
        //
        // ot.setObj(new Integer(30));
        // Integer i = (Integer) ot.getObj();
        // System.out.println("年齡是：" + i);

        // ot.setObj(new String("林青霞"));
        // // ClassCastException
        // Integer ii = (Integer) ot.getObj();
        // System.out.println("姓名是：" + ii);

        System.out.println("-------------");

        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("風(fēng)清揚"));//這個時候編譯期間就過不去
        ot2.setObj(new Integer(27));
        Integer i = ot2.getObj();
        System.out.println("年齡是：" + i);
    }
}
//泛型類：把泛型定義在類上
class ObjectTool<T> {
    private T obj;

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}

5. 泛型方法

把泛型定義在方法上亮蒋，格式:public <泛型類型> 返回類型 方法名(泛型類型 .)

package cn.itcast_05;

public class ObjectToolDemo {
    public static void main(String[] args) {
        // ObjectTool ot = new ObjectTool();
        // ot.show("hello");
        // ot.show(100);
        // ot.show(true);

        // ObjectTool<String> ot = new ObjectTool<String>();
        // ot.show("hello");
        //
        // ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
        // ot2.show(100);
        //
        // ObjectTool<Boolean> ot3 = new ObjectTool<Boolean>();
        // ot3.show(true);

        // 定義泛型方法后
        ObjectTool ot = new ObjectTool();
        ot.show("hello");
        ot.show(100);
        ot.show(true);
    }
}
//泛型方法：把泛型定義在方法上
class ObjectTool {
    public <T> void show(T t) {
        System.out.println(t);
    }
}

6. 泛型接口

把泛型定義在接口上扣典，格式:public interface 接口名<泛型類型1…>

package cn.itcast_06;

public class InterDemo {
    public static void main(String[] args) {
        // 第一種情況的測試
        // Inter<String> i = new InterImpl();
        // i.show("hello");

        // // 第二種情況的測試
        Inter<String> i = new InterImpl<String>();
        i.show("hello");

        Inter<Integer> ii = new InterImpl<Integer>();
        ii.show(100);
    }
}
//泛型接口：把泛型定義在接口上 
interface Inter<T> {
    public abstract void show(T t);
}
// 實現(xiàn)類在實現(xiàn)接口的時候
// 第一種情況：已經(jīng)知道該是什么類型的了

//public class InterImpl implements Inter<String> {
//
//  @Override
//  public void show(String t) {
//      System.out.println(t);
//  }
// }

// 第二種情況：還不知道是什么類型的
class InterImpl<T> implements Inter<T> {

    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

7. 泛型高級(通配符)

為了解決類型被限制死了不能動態(tài)根據(jù)實例來確定的缺點，引入了“通配符泛型”慎玖，針對上面的例子贮尖，使用通配泛型格式為<? extends Collection>，“趁怔？”代表未知類型湿硝，這個類型是實現(xiàn)Collection接口。? extends E：向下限定润努，E及其子類关斜，限定通配符的上邊界。? super E：向上限定铺浇，E及其父類蚤吹，限定通配符的下邊界。

package cn.itcast_07;

import java.util.ArrayList;
import java.util.Collection;

/*
 * 泛型高級(通配符)
 * ?:任意類型，如果沒有明確裁着，那么就是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 {
}

泛型

泛型是提供給javac編譯器使用的桶雀，可以限定集合中的輸入類型矿酵，讓編譯器擋住源程序中的非法輸入，編譯器編譯帶類型說明的集合時會去除掉“類型”信息矗积，使程序運行效率不受影響全肮，對于參數(shù)化的泛型類型，getClass()方法的返回值和原始類型完全一樣棘捣。由于編譯生成的字節(jié)碼會去掉泛型的類型信息辜腺，只要能跳過編譯器，就可以往某個泛型集合中加入其它類型的數(shù)據(jù)乍恐，例如评疗，用反射得到集合，再調(diào)用其add方法即可茵烈。

泛型引用和創(chuàng)建兩端百匆，給出的泛型變量必須相同

泛型類

A<T>
Class<T> type

泛型類中使用泛型

• 成員類型
• 返回值和參數(shù)類型
• 局部變量的引用上

class A<T> {
    private T bean;//泛型可在成員變量上使用
    public T fun(T t) {}//泛型可以在類中的方法上（返回值和參數(shù)類型）使用！
    public void fun2() {//泛型還可以在局部變量的引用類型上使用
        T b = ...
        new T();//不行的呜投！
    }
}

泛型方法

public <T> T add(T x, T y){ 
}

泛型方法與泛型類沒有什么關(guān)系加匈，泛型方法不一定非要在泛型類中！

泛型的繼承和實現(xiàn)

class A<T> {
}

// AA不是泛型類仑荐，只是它爸爸是泛型類矩动！
class AA extends A<String> {
  
} 

繼承泛型類

• 子類不是泛型類：需要給父類傳遞類型常量

當(dāng)給父類傳遞的類型常量為String時，那么在父類中所有T都會被String替換释漆！

class AA1 extends A<String> {
  
}

• 子類是泛型類：可以給父類傳遞類型常量悲没，也可以傳遞類型變量

class AA3<E> extends A<E> {
  
}

通配符

• 無限通配符<?>
• 向下通配符<? extends T>
• 向上通配符<? super T>

類型推斷

• 通過反射的方式獲取泛型的實際類型
• 泛型只能是引用類型，不能是基本數(shù)據(jù)類型

泛型擦除

泛型會在編譯時擦除男图，List<String>和List<User>這兩個的字節(jié)碼文件那一個都是List.class

泛型封裝

本節(jié)內(nèi)容原文鏈接：http://www.reibang.com/p/d62c2be60617

在你真的會用Gson嗎?Gson使用指南（一） 的第三節(jié)我介紹了在Gson中如何使用泛型來簡化我們的類設(shè)計示姿，但隨之而來引入了一個新的問題：封裝。不知道各位有沒有想過這樣一個問題：每次都要用 new TypeToken<XXX>(){}; 好麻煩逊笆，有沒有更好的辦法?

有更好的辦法么?當(dāng)然有栈戳！相信也有不少人自己作了嘗試，只是有人歡喜有人愁了难裆，不過沒關(guān)系子檀，今天我們就來解決這個問題镊掖。

約定

1、本文涉及到的json格式

// data 為 object 的情況
{"code":"0","message":"success","data":{}}
// data 為 array 的情況
{"code":"0","message":"success","data":[]}

2褂痰、假定第一種的對應(yīng)的Java類型為 Result<XXX> 亩进，第二種為 Result<List<XXX>>

為何封裝，如何封裝

1. 為何封裝

• 寫new TypeToken<XXX>(){} 麻煩缩歪，IDE格式化后還不好看
• 不同的地方每進行一次 new TypeToken<XXX>(){} 操作都會生成一個新的類
• 對于任意類XXX都只有兩種情況new TypeToken<Result<XXX>>(){}和new TypeToken<Result<List<XXX>>>(){}
• 方便統(tǒng)一管理

2. 如何封裝

從上面的我們可以知道归薛，最簡單的方法就是提供兩個方法分別對應(yīng)data為Array和Object的情況并接收一個參數(shù)，即告知XXX的類型匪蝙，自動將完成new TypeToken<XXX>(){}與new TypeToken<Result<List<XXX>>>(){}的過程主籍。

方法原型：

// 處理 data 為 object 的情況
public static <T> Result<T> fromJsonObject(Reader reader, Class<T> clazz) {}
// 處理 data 為 array 的情況
public static <T> Result<List<T>> fromJsonArray(Reader reader, Class<T> clazz){}

為何失敗?

對于那些嘗試著封裝過的人可能都這么寫過：

public static <T> Result<List<T>> fromJsonArray(Reader reader) {
    Type type = new TypeToken<Result<List<T>>>(){}.getType();
    return GSON.fromJson(reader, type);
}

當(dāng)然上面的寫法肯定是沒有辦法完成的，雖然代碼不會報錯逛球，但運行結(jié)果肯定是不對的千元，因為這里的T 其實是一個 TypeVariable，他在運行時并不會變成我們想要的XXX颤绕，所以通過TypeToken 得到的 泛型信息只是 "Result<List<T>>"幸海。

如何解決?

既然TypeToken的作用是用于獲取泛型的類，返回的類型為Type屋厘，真正的泛型信息就是放在這個Type里面，既然用TypeToken生成會有問題,那我們自己生成Type就行了嘛月而。

Type是Java中所有類型的父接口汗洒，在1.8以前是一個空接口，自1.8起多了個getTypeName()方法父款，下面有ParameterizedType溢谤、 GenericArrayType、 WildcardType憨攒、 TypeVariable 幾個接口世杀，以及Class類。這幾個接口在本次封裝過程中只會用到 ParameterizedType 肝集，所以簡單說一下：

ParameterizedType 簡單說來就是形如“ 類型<> ”的類型瞻坝，如:Map<String,User>。下面就以 Map<String,User> 為例講一下里面各個方法的作用杏瞻。

public interface ParameterizedType extends Type {
     // 返回Map<String,User>里的String和User所刀，所以這里返回[String.class,User.clas]
    Type[] getActualTypeArguments(); 
    // Map<String,User>里的Map,所以返回值是Map.class
    Type getRawType();
    // 用于這個泛型上中包含了內(nèi)部類的情況,一般返回null
    Type getOwnerType(); 
}

所以，知道了這里需要的泛型是怎么回事捞挥，一切都好說了浮创，下面我們來完成之前留下的空方法。

1. 實現(xiàn)一個簡易的 ParameterizedType

public class ParameterizedTypeImpl implements ParameterizedType {
    private final Class raw;
    private final Type[] args;
    public ParameterizedTypeImpl(Class raw, Type[] args) {
        this.raw = raw;
        this.args = args != null ? args : new Type[0];
    }
    @Override
    public Type[] getActualTypeArguments() {
        return args;
    }
    @Override
    public Type getRawType() {
        return raw;
    }
    @Override
    public Type getOwnerType() {return null;}
}

2. 生成Gson需要的泛型

2.1 解析data是object的情況

public static <T> Result<T> fromJsonObject(Reader reader, Class<T> clazz) {
    Type type = new ParameterizedTypeImpl(Result.class, new Class[]{clazz});
    return GSON.fromJson(reader, type);
}

2.2 解析data是array的情況

是Array的情況要比是Object的情況多那么一步砌函。

public static <T> Result<List<T>> fromJsonArray(Reader reader, Class<T> clazz) {
    // 生成List<T> 中的 List<T>
    Type listType = new ParameterizedTypeImpl(List.class, new Class[]{clazz});
    // 根據(jù)List<T>生成完整的Result<List<T>>
    Type type = new ParameterizedTypeImpl(Result.class, new Type[]{listType});
    return GSON.fromJson(reader, type);
}

本次代碼較少斩披，不提供源碼

雖然這篇博客是以Gson為例溜族，但從上面的內(nèi)容可以看出實際上和Gson關(guān)系不大，主要的內(nèi)容還是Java的泛型基礎(chǔ)垦沉，所以這種封裝的方法同樣適用于其它的框架煌抒。

最后借這次機會給安利一個簡易的泛型生成庫 TypeBuilder ，其最初實現(xiàn)的目的就是讓大家快速的生成泛型信息乡话，同時也會作一些參數(shù)檢查摧玫，保證正確性。

用上面的代碼給大家舉個例子

public static <T> Result<List<T>> fromJsonArray(Reader reader, Class<T> clazz) {
    Type type = TypeBuilder
            .newInstance(Result.class)
            .beginSubType(List.class)
            .addTypeParam(clazz)
            .endSubType()
            .build();
    return GSON.fromJson(reader, type);
}

public static <T> Result<T> fromJsonObject(Reader reader, Class<T> clazz) {
    Type type = TypeBuilder
            .newInstance(Result.class)
            .addTypeParam(clazz)
            .build();
    return GSON.fromJson(reader, type);
}

Type

Type 是 Java 編程語言中所有類型的公共高級接口绑青。它們包括原始類型诬像、參數(shù)化類型、數(shù)組類型闸婴、類型變量和基本類型

ParameterizedType

ParameterizedType 表示參數(shù)化類型坏挠，如 Collection<String>

public abstract class BaseProtocol<T> {
    ...
    /**泛型解析*/
    protected T parsejson(String jsonString){
        ParameterizedType genericSuperclass = (ParameterizedType) getClass().getGenericSuperclass();
        Type[] args = genericSuperclass.getActualTypeArguments();
        Type type = args[0];
        return GsonUtil.changeGsonToBean(jsonString,type);
    }
}