欧美free性护士vide0shd,老熟女,一区二区三区,久久久久夜夜夜精品国产,久久久久久综合网天天,欧美成人护士h版

^{<blockquote id="986rv"></blockquote>}

首頁綜合正文

評論

柚子快報激活碼778899分享：

Extra海外超值購綜合2025-08-22260

柚子快報激活碼778899分享：

http://yzkb.51969.com/

} }

//編譯時生成的字節(jié)碼文件翻譯過來大致如下 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 中的泛型是一種特殊的語法糖，通過類型擦除實現(xiàn)，這種泛型稱為偽泛型，我們可以反射繞過編譯器泛型檢查，添加一個不同類型的參數(shù)

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

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

//使用反射增加一個新的元素 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()); } } //打印結果 erdai 666 123

4、泛型擦除進階

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

在進行網(wǎng)絡請求的時候，傳入一個泛型的實際類型，為啥能夠正確的獲取到該泛型類型，并利用 Gson 轉換為實際的對象？

答：是因為在運行期我們可以使用反射獲取到具體的泛型類型

What? 泛型不是在編譯的時候被擦除了嗎？為啥在運行時還能夠獲取到具體的泛型類型？樂?

答：泛型中所謂的類型擦除，其實只是擦除 Code 屬性中的泛型信息，在類常量池屬性（Signature 屬性、LocalVariableTypeTable 屬性）中其實還保留著泛型信息，而類常量池中的屬性可以被 class 文件，字段表，方法表等攜帶，這就使得我們聲明的泛型信息得以保留，這也是我們在運行時可以反射獲取泛型信息的根本依據(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 引入的泛型，為了彌補泛型擦除的不足，JVM 的 class 文件也做了相應的修改，其中最重要的就是新增了 Signature 屬性表和 LocalVariableTypeTable 屬性表

我們看下下面這段代碼：

class ParentGeneric {

}

class SubClass extends ParentGeneric{

}

class SubClass2 extends ParentGeneric {

}

public class GenericGet {

//獲取實際的泛型類型 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())); } }

//運行這段代碼打印結果如下 subClass: class java.lang.String subClass2: T

上面代碼：

1、 SubClass 相當于對 ParentGeneric 做了賦值操作 T = String，我們通過反射獲取到了泛型類型為 String

2、SubClass2 對 ParentGeneric沒有做賦值操作，我們通過反射獲取到了泛型類型為 T

這里大家肯定會有很多疑問？

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

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

現(xiàn)在我們來仔細分析一波：

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

如果還有點模糊，我們再來看一個例子：

class ParentGeneric {

}

public class GenericGet { //獲取實際的泛型類型 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()));

} } //運行這段代碼打印結果如下 parentGeneric1: null parentGeneric2: class java.lang.String

上述代碼 parentGeneric1 和 parentGeneric2 唯一的區(qū)別就是多了 {}，獲取的結果卻截然不同，我們在來仔細分析一波：

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

這個地方可能大家又會有個疑問了，你既然保留了泛型類型為 T，那么我獲取的時候應該為 T 才是，為啥打印的結果是 null 呢？

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

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

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

在例1中：

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

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

在例2中:

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

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

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

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

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

5、泛型獲取經(jīng)驗總結

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

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

}

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

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

3、邊界

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

1）、Java 中設置邊界使用 extends 關鍵字，完整語法結構：，Bound 可以是類和接口，如果不指定邊界，默認邊界為 Object

2）、可以設置多個邊界，中間使用 & 連接，多個邊界中只能有一個邊界是類，且類必須放在最前面，類似這種語法結構

下面我們來演示一下：

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(); } } //打印結果 test1 test2 test3

4、通配符

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

思考一個問題，代碼如下：

Number number = new Integer(666); ArrayList numberList = new ArrayList();//編譯器報錯 type mismatch

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

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

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

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

3）、泛型不變，假設我定義了一個 Class 的泛型類，其中 A 是 B 的子類，同時 Class 和 Class 沒有繼承關系，那么我們說 Class 在 T 這個泛型上是不變的

因此我們可以知道 ArrayList 的對象不能由 ArrayList 實例化是因為 ArrayList 當前的泛型是不變的，我們要解決上面報錯的問題，可以讓 ArrayList 當前的泛型支持協(xié)變，如下：

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

2、泛型的上邊界通配符