柚子快報(bào)激活碼778899分享：

http://yzkb.51969.com/

} }

//編譯時(shí)生成的字節(jié)碼文件翻譯過(guò)來(lái)大致如下 class MyNode extends Node {

public MyNode(Integer data) { super(data); } // 編譯器生成的橋接方法 public void setData(Object data) { setData((Integer) data); }

public void setData(Integer data) { System.out.println(“MyNode.setData”); super.setData(data); } }

3、偽泛型

Java 中的泛型是一種特殊的語(yǔ)法糖，通過(guò)類型擦除實(shí)現(xiàn)，這種泛型稱為偽泛型，我們可以反射繞過(guò)編譯器泛型檢查，添加一個(gè)不同類型的參數(shù)

//反射繞過(guò)編譯器檢查 public static void main(String[] args) {

List stringList = new ArrayList<>(); stringList.add(“erdai”); stringList.add(“666”);

//使用反射增加一個(gè)新的元素 Class aClass = stringList.getClass(); try { Method method = aClass.getMethod(“add”, Object.class); method.invoke(stringList,123); } catch (Exception e) { e.printStackTrace(); }

Iterator iterator = stringList.iterator(); while (iterator.hasNext()){ System.out.println(iterator.next()); } } //打印結(jié)果 erdai 666 123

4、泛型擦除進(jìn)階

下面我拋出一個(gè)在工作中經(jīng)常會(huì)遇到的問(wèn)題：

在進(jìn)行網(wǎng)絡(luò)請(qǐng)求的時(shí)候，傳入一個(gè)泛型的實(shí)際類型，為啥能夠正確的獲取到該泛型類型，并利用 Gson 轉(zhuǎn)換為實(shí)際的對(duì)象？

答：是因?yàn)樵谶\(yùn)行期我們可以使用反射獲取到具體的泛型類型

What? 泛型不是在編譯的時(shí)候被擦除了嗎？為啥在運(yùn)行時(shí)還能夠獲取到具體的泛型類型？樂(lè)?

答：泛型中所謂的類型擦除，其實(shí)只是擦除 Code 屬性中的泛型信息，在類常量池屬性（Signature 屬性、LocalVariableTypeTable 屬性）中其實(shí)還保留著泛型信息，而類常量池中的屬性可以被 class 文件，字段表，方法表等攜帶，這就使得我們聲明的泛型信息得以保留，這也是我們?cè)谶\(yùn)行時(shí)可以反射獲取泛型信息的根本依據(jù)

//這是反編譯后的 JavaGenericClass.class 文件，可以看到 T public class JavaGenericClass {

private T a;

public JavaGenericClass(T a) { this.a = a; }

public T getA() { return a; }

public void setA(T a) { this.a = a; }

//… }

注意：Java 是在 JDK 1.5 引入的泛型，為了彌補(bǔ)泛型擦除的不足，JVM 的 class 文件也做了相應(yīng)的修改，其中最重要的就是新增了 Signature 屬性表和 LocalVariableTypeTable 屬性表

我們看下下面這段代碼：

class ParentGeneric {

}

class SubClass extends ParentGeneric{

}

class SubClass2 extends ParentGeneric {

}

public class GenericGet {

//獲取實(shí)際的泛型類型 public static Type findGenericType(Class cls) { Type genType = cls.getGenericSuperclass(); Type finalNeedType = null; if (genType instanceof ParameterizedType) { Type[] params = ((ParameterizedType) genType).getActualTypeArguments(); finalNeedType = params[0]; } return finalNeedType; }

public static void main(String[] args) { SubClass subClass = new SubClass(); SubClass2 subClass2 = new SubClass2(); //打印 subClass 獲取的泛型 System.out.println("subClass: " + findNeedClass(subClass.getClass())); //打印subClass2獲取的泛型 System.out.println("subClass2: " + findGenericType(subClass2.getClass())); } }

//運(yùn)行這段代碼 打印結(jié)果如下 subClass: class java.lang.String subClass2: T

上面代碼：

1、 SubClass 相當(dāng)于對(duì) ParentGeneric 做了賦值操作 T = String，我們通過(guò)反射獲取到了泛型類型為 String

2、SubClass2 對(duì) ParentGeneric沒(méi)有做賦值操作 ，我們通過(guò)反射獲取到了泛型類型為 T

這里大家肯定會(huì)有很多疑問(wèn)？

1、為啥 1 中沒(méi)有傳入任何泛型的信息卻能獲取到泛型類型呢？

2、為啥 2 中我創(chuàng)建對(duì)象的時(shí)候傳入的泛型是 Integer ，獲取的時(shí)候變成了 T 呢？

現(xiàn)在我們來(lái)仔細(xì)分析一波：

上面我講過(guò)，類型擦除其實(shí)只是擦除 Code 屬性中的泛型信息，在類常量池屬性中還保留著泛型信息，因此上面的 SubClass 和SubClass2 在編譯的時(shí)候其實(shí)會(huì)保留各自的泛型到字節(jié)碼文件中，一個(gè)是 String，一個(gè)是 T 。而 subClass 和 subClass2 是運(yùn)行時(shí)動(dòng)態(tài)創(chuàng)建的，這個(gè)時(shí)候你即使傳入了泛型類型，也會(huì)被擦除掉，因此才會(huì)出現(xiàn)上面的結(jié)果，到這里，大家是否明了了呢？

如果還有點(diǎn)模糊，我們?cè)賮?lái)看一個(gè)例子：

class ParentGeneric {

}

public class GenericGet { //獲取實(shí)際的泛型類型 public static Type findGenericType(Class cls) { Type genType = cls.getGenericSuperclass(); Type finalNeedType = null; if (genType instanceof ParameterizedType) { Type[] params = ((ParameterizedType) genType).getActualTypeArguments(); finalNeedType = params[0]; } return finalNeedType; }

public static void main(String[] args) { ParentGeneric parentGeneric1 = new ParentGeneric(); ParentGeneric parentGeneric2 = new ParentGeneric(){};

//打印 parentGeneric1 獲取的泛型 System.out.println("parentGeneric1: " + findGenericType(parentGeneric1.getClass())); //打印 parentGeneric2 獲取的泛型 System.out.println("parentGeneric2: " + findGenericType(parentGeneric2.getClass()));

} } //運(yùn)行這段代碼 打印結(jié)果如下 parentGeneric1: null parentGeneric2: class java.lang.String

上述代碼 parentGeneric1 和 parentGeneric2 唯一的區(qū)別就是多了 {}，獲取的結(jié)果卻截然不同，我們?cè)趤?lái)仔細(xì)分析一波：

1、 ParentGeneric 聲明的泛型 T 在編譯的時(shí)候其實(shí)是保留在了字節(jié)碼文件中，parentGeneric1 是在運(yùn)行時(shí)創(chuàng)建的，由于泛型擦除，我們無(wú)法通過(guò)反射獲取其中的類型，因此打印了 null

這個(gè)地方可能大家又會(huì)有個(gè)疑問(wèn)了，你既然保留了泛型類型為 T，那么我獲取的時(shí)候應(yīng)該為 T 才是，為啥打印的結(jié)果是 null 呢？

如果你心里有這個(gè)疑問(wèn)，說(shuō)明你思考的非常細(xì)致，要理解這個(gè)問(wèn)題，我們首先要對(duì) Java 類型（Type）系統(tǒng)有一定的了解，這其實(shí)和我上面寫的那個(gè)獲取泛型類型的方法有關(guān)：

//獲取實(shí)際的泛型類型 public static Type findGenericType(Class cls) { //獲取當(dāng)前帶有泛型的父類 Type genType = cls.getGenericSuperclass(); Type finalNeedType = null; //如果當(dāng)前 genType 是參數(shù)化類型則進(jìn)入到條件體 if (genType instanceof ParameterizedType) { //獲取參數(shù)類型 <> 里面的那些值,例如 Map 那么就得到 [K,V]的一個(gè)數(shù)組 Type[] params = ((ParameterizedType) genType).getActualTypeArguments(); //將第一個(gè)泛型類型賦值給 finalNeedType finalNeedType = params[0]; } return finalNeedType; }

上述代碼我們需要先獲取這個(gè)類的泛型父類，如果是參數(shù)化類型則進(jìn)入到條件體，獲取實(shí)際的泛型類型并返回。如果不是則直接返回 finalNeedType , 那么這個(gè)時(shí)候就為 null 了

在例1中：

SubClass1 subClass1 = new SubClass1(); SubClass2 subClass2 = new SubClass2<>(); System.out.println(subClass1.getClass().getGenericSuperclass()); System.out.println(subClass2.getClass().getGenericSuperclass()); //運(yùn)行程序 打印結(jié)果如下 com.dream.java_generic.share.ParentGeneric com.dream.java_generic.share.ParentGeneric

可以看到獲取到了泛型父類，因此會(huì)走到條件體里面獲取到實(shí)際的泛型類型并返回

在例2中:

ParentGeneric parentGeneric1 = new ParentGeneric(); System.out.println(parentGeneric1.getClass().getGenericSuperclass()); //運(yùn)行程序 打印結(jié)果如下 class java.lang.Object

可以看到獲取到的泛型父類是 Object，因此進(jìn)不去條件體，所以就返回 null 了

2、parentGeneric2 在創(chuàng)建的時(shí)候后面加了 {}，這就使得 parentGeneric2 成為了一個(gè)匿名內(nèi)部類，且父類就是 ParentGeneric，因?yàn)槟涿麅?nèi)部類是在編譯時(shí)創(chuàng)建的，那么在編譯的時(shí)候就會(huì)創(chuàng)建并攜帶具體的泛型信息，因此 parentGeneric2 可以獲取其中的泛型類型

通過(guò)上面兩個(gè)例子我們可以得出結(jié)論：如果在編譯的時(shí)候就保存了泛型類型到字節(jié)碼中，那么在運(yùn)行時(shí)我們就可以通過(guò)反射獲取到，如果在運(yùn)行時(shí)傳入實(shí)際的泛型類型，這個(gè)時(shí)候就會(huì)被擦除，反射獲取不到當(dāng)前傳入的泛型實(shí)際類型

例子1中我們指定了泛型的實(shí)際類型為 String，編譯的時(shí)候就將它存儲(chǔ)到了字節(jié)碼文件中，因此我們獲取到了泛型類型。例子2中我們創(chuàng)建了一個(gè)匿名內(nèi)部類，同樣在編譯的時(shí)候會(huì)進(jìn)行創(chuàng)建并保存了實(shí)際的泛型到字節(jié)碼中，因此我們可以獲取到。而 parentGeneric1 是在運(yùn)行時(shí)創(chuàng)建的，雖然 ParentGeneric 聲明的泛型 T 在編譯時(shí)也保留在了字節(jié)碼文件中，但是它傳入的實(shí)際類型被擦除了，這種泛型也是無(wú)法通過(guò)反射獲取的，記住上面這條結(jié)論，那么對(duì)于泛型類型的獲取你就得心應(yīng)手了

5、泛型獲取經(jīng)驗(yàn)總結(jié)

其實(shí)通過(guò)上面兩個(gè)例子可以發(fā)現(xiàn)，當(dāng)我們定義一個(gè)子類繼承一個(gè)泛型父類，并給這個(gè)泛型一個(gè)類型，我們就可以獲取到這個(gè)泛型類型

//定義一個(gè)子類繼承泛型父類，并給這個(gè)泛型一個(gè)實(shí)際的類型 class SubClass extends ParentGeneric{

}

//匿名內(nèi)部類，其實(shí)我們定義的這個(gè)匿名內(nèi)部類也是一個(gè)子類，它繼承了泛型父類，并給這個(gè)泛型一個(gè)實(shí)際的類型 ParentGeneric parentGeneric2 = new ParentGeneric(){};

因此如果我們想要獲取某個(gè)泛型類型，我們可以通過(guò)子類的幫助去取出該泛型類型，一種良好的編程實(shí)踐就是把當(dāng)前需要獲取的泛型類用 abstract 聲明

3、邊界

邊界就是在泛型的參數(shù)上設(shè)置限制條件，這樣可以強(qiáng)制泛型可以使用的類型，更重要的是可以按照自己的邊界類型來(lái)調(diào)用方法

1）、Java 中設(shè)置邊界使用 extends 關(guān)鍵字，完整語(yǔ)法結(jié)構(gòu)： ，Bound 可以是類和接口，如果不指定邊界，默認(rèn)邊界為 Object

2）、可以設(shè)置多個(gè)邊界，中間使用 & 連接，多個(gè)邊界中只能有一個(gè)邊界是類，且類必須放在最前面，類似這種語(yǔ)法結(jié)構(gòu)

下面我們來(lái)演示一下：

abstract class ClassBound{ public abstract void test1(); }

interface InterfaceBound1{ void test2(); }

interface InterfaceBound2{ void test3(); }

class ParentClass { private final T item;

public ParentClass(T item) { this.item = item; }

public void test1(){ item.test1(); }

public void test2(){ item.test2(); }

public void test3(){ item.test3(); } }

class SubClass extends ClassBound implements InterfaceBound1,InterfaceBound2 {

@Override public void test1() { System.out.println(“test1”); }

@Override public void test2() { System.out.println(“test2”); }

@Override public void test3() { System.out.println(“test3”); } }

public class Bound { public static void main(String[] args) { SubClass subClass = new SubClass(); ParentClass parentClass = new ParentClass(subClass); parentClass.test1(); parentClass.test2(); parentClass.test3(); } } //打印結(jié)果 test1 test2 test3

4、通配符

1、泛型的協(xié)變，逆變和不變

思考一個(gè)問(wèn)題，代碼如下：

Number number = new Integer(666); ArrayList numberList = new ArrayList();//編譯器報(bào)錯(cuò) type mismatch

上述代碼，為啥 Number 的對(duì)象可以由 Integer 實(shí)例化，而 ArrayList 的對(duì)象卻不能由 ArrayList 實(shí)例化？

要明白上面這個(gè)問(wèn)題，我們首先要明白，什么是泛型的協(xié)變，逆變和不變

1）、泛型協(xié)變，假設(shè)我定義了一個(gè) Class 的泛型類，其中 A 是 B 的子類，同時(shí) Class 也是 Class 的子類，那么我們說(shuō) Class 在 T 這個(gè)泛型上是協(xié)變的

2）、泛型逆變，假設(shè)我定義了一個(gè) Class 的泛型類，其中 A 是 B 的子類，同時(shí) Class 也是 Class 的子類，那么我們說(shuō) Class 在 T 這個(gè)泛型上是逆變的

3）、泛型不變，假設(shè)我定義了一個(gè) Class 的泛型類，其中 A 是 B 的子類，同時(shí) Class 和 Class 沒(méi)有繼承關(guān)系，那么我們說(shuō) Class 在 T 這個(gè)泛型上是不變的

因此我們可以知道 ArrayList 的對(duì)象不能由 ArrayList 實(shí)例化是因?yàn)?ArrayList 當(dāng)前的泛型是不變的，我們要解決上面報(bào)錯(cuò)的問(wèn)題，可以讓 ArrayList 當(dāng)前的泛型支持協(xié)變，如下：

Number number = new Integer(666); ArrayList numberList = new ArrayList();

2、泛型的上邊界通配符

1）、泛型的上邊界通配符語(yǔ)法結(jié)構(gòu)：，使得泛型支持協(xié)變，它限定的類型是當(dāng)前上邊界類或者其子類，如果是接口的話就是當(dāng)前上邊界接口或者實(shí)現(xiàn)類，使用上邊界通配符的變量只讀，不可以寫，可以添加 null ，但是沒(méi)意義

public class WildCard { public static void main(String[] args) { List integerList = new ArrayList(); List numberList = new ArrayList(); integerList.add(666); numberList.add(123);

getNumberData(integerList); getNumberData(numberList); }

public static void getNumberData(List data) { System.out.println(“Number data :” + data.get(0)); } } //打印結(jié)果 Number data: 666 Number data: 123

問(wèn)題：為啥使用上邊界通配符的變量只讀，而不能寫？

1、,它限定的類型是當(dāng)前上邊界類或者其子類，它無(wú)法確定自己具體的類型，因此編譯器無(wú)法驗(yàn)證類型的安全，所以不能寫

2、假設(shè)可以寫，我們向它里面添加若干個(gè)子類，然后用一個(gè)具體的子類去接收，勢(shì)必會(huì)造成類型轉(zhuǎn)換異常

3、泛型的下邊界通配符

1）、泛型的下邊界通配符語(yǔ)法結(jié)構(gòu)：，使得泛型支持逆變，它限定的類型是當(dāng)前下邊界類或者其父類，如果是接口的話就是當(dāng)前下邊界接口或者其父接口，使用下邊界通配符的變量只寫，不建議讀

public class WildCard {

public static void main(String[] args) { List numberList = new ArrayList(); List objectList = new ArrayList(); setNumberData(numberList); setNumberData(objectList); }

public static void setNumberData(List data) { Number number = new Integer(666); data.add(number); } }

問(wèn)題：為啥使用下邊界通配符的變量可以寫，而不建議讀？

1、，它限定的類型是當(dāng)前下邊界類或者其父類，雖然它也無(wú)法確定自己具體的類型，但根據(jù)多態(tài)，它能保證自己添加的元素是安全的，因此可以寫

2、獲取值的時(shí)候，會(huì)返回一個(gè) Object 類型的值，而不能獲取實(shí)際類型參數(shù)代表的類型，因此建議不要去讀，如果你實(shí)在要去讀也行，但是要注意類型轉(zhuǎn)換異常

4、泛型的無(wú)邊界通配符

1）、無(wú)邊界通配符的語(yǔ)法結(jié)構(gòu)：，實(shí)際上它等價(jià)于 ，也就是說(shuō)它的上邊界是 Object 或其子類，因此使用無(wú)界通配符的變量同樣只讀，不能寫，可以添加 null ，但是沒(méi)意義

public class WildCard {

public static void main(String[] args) { List stringList = new ArrayList(); List numberList = new ArrayList(); List integerList = new ArrayList(); stringList.add(“erdai”); numberList.add(666); integerList.add(123); getData(stringList); getData(numberList); getData(integerList); }

public static void getData(List data) { System.out.println("data: " + data.get(0)); } } //打印結(jié)果 data: erdai data: 666 data: 123

5、PECS 原則

泛型代碼的設(shè)計(jì)，應(yīng)遵循PECS原則（Producer extends Consumer super）：

1）、如果只需要獲取元素，使用

2）、如果只需要存儲(chǔ)，使用

//這是 Collections.java 中 copy 方法的源碼 public static void copy(List dest, List src) { //… }

這是一個(gè)很經(jīng)典的例子，src 表示原始集合，使用了 ，只能從中讀取元素，dest 表示目標(biāo)集合，只能往里面寫元素，充分的體現(xiàn)了 PECS 原則

6、使用通配符總結(jié)

1）、當(dāng)你只想讀取值的時(shí)候，使用

2）、當(dāng)你只想寫入值的時(shí)候，使用

3）、當(dāng)你既想讀取值又想寫入值的時(shí)候，就不要使用通配符

5、泛型的限制

1）、泛型不能顯式地引用在運(yùn)行時(shí)類型的操作里，如 instanceof 操作和 new 表達(dá)式，運(yùn)行時(shí)類型只適用于原生類型

public class GenericLimitedClass { private void test(){ String str = “”; //編譯器不允許這種操作 if(str instanceof T){

} //編譯器不允許這種操作 T t = new T(); } }

2）、不能創(chuàng)建泛型類型的數(shù)組，只可以聲明一個(gè)泛型類型的數(shù)組引用

public class GenericLimitedClass { private void test(){ GenericLimitedClass[] genericLimitedClasses; //編譯器不允許 genericLimitedClasses = new GenericLimitedClass[10]; } }

3）、不能聲明類型為泛型的靜態(tài)字段

public class GenericLimitedClass { //編譯器不允許 private static T t; }

4）、泛型類不可以直接或間接地繼承 Throwable

//編譯器不允許 public class GenericLimitedClass extends Throwable {

}

5）、方法中不可以捕獲類型參數(shù)的實(shí)例，但是可以在 throws 語(yǔ)句中使用類型參數(shù)

public class GenericLimitedClass { private void test1() throws T{ try {

//編譯器不允許 }catch (T exception){

} } }

6）、一個(gè)類不可以重載在類型擦除后有同樣方法簽名的方法

public class GenericLimitedClass { //編譯器不允許 private void test2(List stringList){

}

private void test2(List integerList){

} }

6、問(wèn)題

1）、類型邊界和通配符邊界有什么區(qū)別？

類型邊界可以有多個(gè)，通配符邊界只能有一個(gè)

2）、List 和 List