淺析Java泛型

godiscoder 發(fā)布于2019-08-16 17:51 / 2948人閱讀

摘要：泛型類在類的申明時(shí)指定參數(shù)，即構(gòu)成了泛型類。換句話說(shuō)，泛型類可以看成普通類的工廠。的作用就是指明泛型的具體類型，而類型的變量，可以用來(lái)創(chuàng)建泛型類的對(duì)象。只有聲明了的方法才是泛型方法，泛型類中的使用了泛型的成員方法并不是泛型方法。

什么是泛型？

泛型是JDK 1.5的一項(xiàng)新特性，它的本質(zhì)是參數(shù)化類型（Parameterized Type）的應(yīng)用，也就是說(shuō)所操作的數(shù)據(jù)類型被指定為一個(gè)參數(shù)，在用到的時(shí)候在指定具體的類型。這種參數(shù)類型可以用在類、接口和方法的創(chuàng)建中，分別稱為泛型類、泛型接口和泛型方法。

基本術(shù)語(yǔ)介紹

以ArrayList和ArrayList為例
整個(gè)ArrayList稱為泛型類型
ArrayList中的E稱為類型變量或者類型形參
整個(gè)ArrayList稱為參數(shù)化的類型
ArrayList中的Integer稱為類型參數(shù)的實(shí)例或者類型實(shí)參
ArrayList中的念為typeof Integer
ArrayList稱為原始類型

為什么使用泛型？

泛型使類型（類和接口）在定義類、接口和方法時(shí)成為參數(shù)，好處在于：

強(qiáng)化類型安全，由于泛型在編譯期進(jìn)行類型檢查，從而保證類型安全，減少運(yùn)行期的類型轉(zhuǎn)換異常。

提高代碼復(fù)用，泛型能減少重復(fù)邏輯，編寫更簡(jiǎn)潔的代碼。

類型依賴關(guān)系更加明確，接口定義更加優(yōu)好，增強(qiáng)了代碼和文檔的易讀性。

一個(gè)簡(jiǎn)單的例子

public class Test1 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("kiwen1");
        list.add("kiwen2");
        list.add(123);

        for (int i = 0; i < list.size(); i++) {
            String name = (String) list.get(i); 
            System.out.println("name:" + name);
        }
        
    }
}
//輸出結(jié)果
name:kiwen1
name:kiwen2
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    at DateTest.Test1.main(Test.java:17)

從上面例子可以看出，定義了一個(gè)List類型的集合，向其中加入了兩個(gè)字符串類型的值和一個(gè)Integer類型的值。此時(shí)list默認(rèn)的類型為Object類型。但這里有兩個(gè)問(wèn)題，在循環(huán)中，一是當(dāng)獲取一個(gè)值時(shí)必須進(jìn)行強(qiáng)制類型轉(zhuǎn)換，二是沒(méi)有錯(cuò)誤檢查。由于定義了name為String類型，運(yùn)行時(shí)將Integer轉(zhuǎn)成String會(huì)產(chǎn)生錯(cuò)誤。即編譯階段正常，而運(yùn)行時(shí)會(huì)出現(xiàn)“java.lang.ClassCastException”異常。因此，導(dǎo)致此類錯(cuò)誤編碼過(guò)程中不易被發(fā)現(xiàn)。

public class Test2 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("kiwen1");
        list.add("kiwen2");
        //list.add(123);   //提示編譯錯(cuò)誤

        for (int i = 0; i < list.size(); i++) {
            String name = list.get(i);
            System.out.println("name:" + name);
        }
    }
}
//輸出結(jié)果
name:kiwen1
name:kiwen2

該段代碼采用泛型寫法后，向list加入一個(gè)Integer類型的對(duì)象時(shí)會(huì)出現(xiàn)編譯錯(cuò)誤，通過(guò)List，直接限定了list集合中只能含有String類型的元素，從而在輸出時(shí)處無(wú)須進(jìn)行強(qiáng)制類型轉(zhuǎn)換。因?yàn)榇藭r(shí)，集合能夠記住元素的類型信息，編譯器已經(jīng)能夠確認(rèn)它是String類型了。

通過(guò)上面的例子可以證明，在編譯之后程序會(huì)采取去泛型化的措施。也就是說(shuō)Java中的泛型，只在編譯階段有效。在編譯過(guò)程中，正確檢驗(yàn)泛型結(jié)果后，會(huì)將泛型的相關(guān)信息擦出，并且在對(duì)象進(jìn)入和離開(kāi)方法的邊界處添加類型檢查和類型轉(zhuǎn)換的方法。也就是說(shuō)，泛型信息不會(huì)進(jìn)入到運(yùn)行時(shí)階段。對(duì)此總結(jié)成一句話：泛型類型在邏輯上看以看成是多個(gè)不同的類型，實(shí)際上都是相同的基本類型。

泛型類

在類的申明時(shí)指定參數(shù)，即構(gòu)成了泛型類。泛型類的類型參數(shù)部分可以有一個(gè)或多個(gè)類型參數(shù)，它們之間用逗號(hào)分隔。這些類稱為參數(shù)化類或參數(shù)化類型，因?yàn)樗鼈兘邮芤粋€(gè)或多個(gè)參數(shù)。

定義一個(gè)簡(jiǎn)單的泛型類

//在實(shí)例化泛型類時(shí)，必須指定T的具體類型
public class Test{
    //在類中聲明的泛型整個(gè)類里面都可以用，除了靜態(tài)部分，因?yàn)榉盒褪菍?shí)例化時(shí)聲明的。
    //靜態(tài)區(qū)域的代碼在編譯時(shí)就已經(jīng)確定，只與類相關(guān)
    class A {
        T t;
    }
    //類里面的方法或類中再次聲明同名泛型是允許的，并且該泛型會(huì)覆蓋掉父類的同名泛型T
    class B {
        T t;
    }
    //靜態(tài)內(nèi)部類也可以使用泛型，實(shí)例化時(shí)賦予泛型實(shí)際類型
    static class C  {
        T t;
    }
    public static void main(String[] args) {
        //報(bào)錯(cuò)，不能使用T泛型，因?yàn)榉盒蚑屬于實(shí)例不屬于類
//        T t = null;
    }

    //key這個(gè)成員變量的類型為T,T的類型由外部指定
    private T key;

    public Test(T key) { //泛型構(gòu)造方法形參key的類型也為T，T的類型由外部指定
        this.key = key;
    }

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

在使用泛型的時(shí)候如果傳入泛型實(shí)參，則會(huì)根據(jù)傳入的泛型實(shí)參做相應(yīng)的限制，此時(shí)泛型才會(huì)起到本應(yīng)起到的限制作用，但是，泛型的類型參數(shù)只能是類類型，不能是簡(jiǎn)單類型。如果不傳入泛型類型實(shí)參的話，在泛型類中使用泛型的方法或成員變量定義的類型可以為任何的類型。換句話說(shuō)，泛型類可以看成普通類的工廠。

//不傳入泛型類型實(shí)參
List list = new List();
list.add(123);
list.add("hello");
//傳入的泛型實(shí)參
List list = new List();
list.add("hello");

如何繼承一個(gè)泛型類

如果不傳入具體的類型，則子類也需要指定類型參數(shù)，

class Son extends Test{}

如果傳入具體參數(shù)，則子類不需要指定類型參數(shù)

class Son extends Test{}

泛型接口

泛型接口與泛型類的定義基本一致

//定義一個(gè)泛型接口
public interface Generator {
    public T next();
}

如何實(shí)現(xiàn)一個(gè)泛型接口

一個(gè)簡(jiǎn)單的例子

/**
 * 傳入泛型實(shí)參時(shí)：
 * 定義一個(gè)生產(chǎn)器實(shí)現(xiàn)這個(gè)接口,雖然我們只創(chuàng)建了一個(gè)泛型接口Generator
 * 但是我們可以為T傳入無(wú)數(shù)個(gè)實(shí)參，形成無(wú)數(shù)種類型的Generator接口。
 * 在實(shí)現(xiàn)類實(shí)現(xiàn)泛型接口時(shí)，如已將泛型類型傳入實(shí)參類型，則所有使用泛型的地方都要替換成傳入的實(shí)參類型
 * 即：Generator，public T next();中的的T都要替換成傳入的String類型。
 */

public class FruitGenerator implements Generator {
    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

泛型通配符

我們知道，Box和Box實(shí)際上都是Box類型，現(xiàn)在需要繼續(xù)探討一個(gè)問(wèn)題，那么在邏輯上，類似于Box和Box是否可以看成具有父子關(guān)系的泛型類型呢？

為了弄清楚這個(gè)問(wèn)題，我們使用Box這個(gè)泛型類繼續(xù)看下面的例子：

package DateTest;
public class GenericTest {
    class Box {
        private T data;
        public Box() {
        }
        public Box(T data) {
            this.data = data;
        }
        public T getData() {
            return data;
        }
        public void setData(T data) {
        this.data = data;
        }
    }
    public static void main(String[] args) {
        Box name = new Box(99);
        Box age = new Box(712);
        getData(name);
        //The method getData(Box) in the type GenericTest is 
        //not applicable for the arguments (Box)
        getData(age);   // 1
    }
    public static void getData(Box data){
        System.out.println("data :" + data.getData());
    }
}

通過(guò)提示信息我們可以看到Box不能被看作為Box的子類。由此可以看出:同一種泛型可以對(duì)應(yīng)多個(gè)版本（因?yàn)閰?shù)類型是不確定的），不同版本的泛型類實(shí)例是不兼容的。

回到上面的例子，如何解決上面的問(wèn)題？總不能為了定義一個(gè)新的方法來(lái)處理Generic類型的類，這顯然與java中的多態(tài)理念相違背。因此我們需要一個(gè)在邏輯上可以表示同時(shí)是Box和Box的父類的引用類型。由此類型通配符應(yīng)運(yùn)而生。

我們可以將上面的方法改一下：

public static void getData(Box data) {
    System.out.println("data :" + data.getData());
}

類型通配符一般是使用？代替具體的類型實(shí)參，注意，此處的？和Number、String、Integer一樣都是一種實(shí)際的類型，可以把？看成所有類型的父類。是一種真實(shí)的類型。

可以解決當(dāng)具體類型不確定的時(shí)候，這個(gè)通配符就是 ? ；當(dāng)操作類型時(shí)，不需要使用類型的具體功能時(shí)，只使用Object類中的功能。那么可以用 ? 通配符來(lái)表未知類型。

泛型無(wú)限定通配符

無(wú)限定通配符使用的格式，代表未知類型的泛型。當(dāng)可以使用Object類中提供的功能或當(dāng)代碼獨(dú)立于類型參數(shù)來(lái)實(shí)現(xiàn)方法時(shí)，這樣的參數(shù)可以使用任何對(duì)象。

public void showKeyValue1(List list) {
    for (Object item : list) {  
        System.out.print(item + " ");   
    } 
}

泛型上限通配符

通配符上界使用的格式，意思是需要一個(gè)T類型或者T類型的子類，一般T類型都是一個(gè)具體的類型，例如下面的代碼。

//只能傳入number的子類或者number
public void showKeyValue2(List list) {  
    for (Number number : list) {  
        System.out.print(number.intValue()+" ");   
    }  
}
//假如傳入String類型，list.add("hello");會(huì)提示
//The method add(Number) in the type List is not applicable for the arguments (String)

無(wú)論傳入的是何種類型的集合，我們都可以使用其父類的方法統(tǒng)一處理。

泛型下限通配符

通配符下界使用的格式，意思是需要一個(gè)T類型或者T類型的父類，一般T類型都是一個(gè)具體的類型，例如下面的代碼。

//只能傳入Integer的父類或者Integer
public void showKeyValue3(List obj){
    System.out.println(obj);
}
//假如傳入String類型，list.add("hello");會(huì)提示
//The method add(Number) in the type List is not applicable for the arguments (String)

泛型方法

在java中，泛型類的定義非常簡(jiǎn)單，但是泛型方法就比較復(fù)雜了。
尤其是我們見(jiàn)到的大多數(shù)泛型類中的成員方法也都使用了泛型，有的甚至泛型類中也包含著泛型方法，這樣在初學(xué)者中非常容易將泛型方法理解錯(cuò)了。
泛型類，是在實(shí)例化類的時(shí)候指明泛型的具體類型；泛型方法，是在調(diào)用方法的時(shí)候指明泛型的具體類型。

定義泛型方法如下

調(diào)用泛型方法如下

定義泛型方法時(shí)，必須在返回值前邊加一個(gè)，來(lái)聲明這是一個(gè)泛型方法，持有一個(gè)泛型T，然后才可以用泛型T作為方法的返回值。
Class的作用就是指明泛型的具體類型，而Class類型的變量c，可以用來(lái)創(chuàng)建泛型類的對(duì)象。
為什么要用變量c來(lái)創(chuàng)建對(duì)象呢？既然是泛型方法，就代表著我們不知道具體的類型是什么，也不知道構(gòu)造方法如何，因此沒(méi)有辦法去new一個(gè)對(duì)象，但可以利用變量c的newInstance方法去創(chuàng)建對(duì)象，也就是利用反射創(chuàng)建對(duì)象。
泛型方法要求的參數(shù)是Class類型，而Class.forName()方法的返回值也是Class，因此可以用Class.forName()作為參數(shù)。其中，forName()方法中的參數(shù)是何種類型，返回的Class就是何種類型。在本例中，forName()方法中傳入的是User類的完整路徑，因此返回的是Class類型的對(duì)象，因此調(diào)用泛型方法時(shí)，變量c的類型就是Class，因此泛型方法中的泛型T就被指明為User，因此變量obj的類型為User。

/**
 * 泛型方法的基本介紹
 * 說(shuō)明：
 *     1）public 與 返回值中間非常重要，可以理解為聲明此方法為泛型方法。
 *     2）只有聲明了的方法才是泛型方法，泛型類中的使用了泛型的成員方法并不是泛型方法。
 *     3）表明該方法將使用泛型類型T，此時(shí)才可以在方法中使用泛型類型T。
 *     4）與泛型類的定義一樣，此處T可以隨便寫為任意標(biāo)識(shí)，常見(jiàn)的如T、E、K、V等形式的參數(shù)常用于表示泛型。
 */
public class Generic {
    public T name;
    public  Generic(){}
    public Generic(T param){
        name=param;
    }
    public T m(){
        return name;
    }
    public  void m1(E e){ }
    public  T m2(T e){ }
}

上面代碼中，m()方法不是泛型方法，m1()和m2()都是泛型方法。

泛型方法與可變參數(shù)

public class Test{
    @Test
    public void test () {
        printMsg("hello1",1,"hello2",2.0,false);
        print("hello1","hello2", "hello3");
    }
    //普通可變參數(shù)只能適配一種類型
    public void print(String ... args) {
        for(String t : args){
            System.out.println(t);
        }
    }
    //泛型的可變參數(shù)可以匹配所有類型的參數(shù)。。有點(diǎn)無(wú)敵
    public  void printMsg( T... args){
        for(T t : args){
            System.out.println(t);
        }
    }
}

靜態(tài)方法與泛型

如果在類中定義使用泛型的靜態(tài)方法，需要添加額外的泛型聲明（將這個(gè)方法定義成泛型方法）。即使靜態(tài)方法要使用泛型類中已經(jīng)聲明過(guò)的泛型也不可以。

public class Test {
    private static T num;//此時(shí)編譯器會(huì)提示錯(cuò)誤信息
    public static void test(T t){//此時(shí)編譯器會(huì)提示錯(cuò)誤信息:
        ...
        //Cannot make a static reference to the non-static type T
    }
}

因?yàn)殪o態(tài)方法和靜態(tài)變量屬于類所有，而泛型類中的泛型參數(shù)的實(shí)例化是在創(chuàng)建泛型類型對(duì)象時(shí)指定的，所以如果不創(chuàng)建對(duì)象，根本無(wú)法確定參數(shù)類型。但是靜態(tài)泛型方法是可以使用的，我們前面說(shuō)過(guò)，泛型方法里面的那個(gè)類型和泛型類那個(gè)類型完全是兩回事。

public class StaticGenerator {
    public static  void show(T t){
    }
}

泛型的限制

Java泛型不能使用原始類型

使用泛型，原始類型不能作為類型參數(shù)傳遞。例如

Test test = new Test();

如果將int原始類型傳遞給Test類，那么編譯器會(huì)報(bào)錯(cuò)。為了避免這種情況，需要傳遞Integer對(duì)象而不是int原始類型。

Java泛型不能使用實(shí)例

類型參數(shù)不能用于在方法中實(shí)例化其對(duì)象。例如

public static  void show(Test test) {
   //compiler error
   //Cannot instantiate the type T
   //T item = new T();  
   //test.add(item);
}

如果需要實(shí)現(xiàn)這樣的功能，可以使用反射。

public static  void show(Test test, Class clazz) 
   throws InstantiationException, IllegalAccessException{
   T item = clazz.newInstance();   // OK
   test.add(item);
   System.out.println("Item showed.");
}

Java泛型不能使用靜態(tài)域

使用泛型時(shí)，類型參數(shù)不允許為靜態(tài)(static)。由于靜態(tài)變量在對(duì)象之間共享，因此編譯器無(wú)法確定要使用的類型。如果允許靜態(tài)類型參數(shù)。

Java泛型不能轉(zhuǎn)換類型

除非由無(wú)界通配符進(jìn)行參數(shù)化，否則不允許轉(zhuǎn)換為參數(shù)化類型。

Test integerTest = new Test();
Test numberTest = new Test();
//Compiler Error: Cannot cast from Test to Test，下面用法是錯(cuò)誤的
integerTest = (Test)numberTest;
//可以使用無(wú)界通配符進(jìn)行轉(zhuǎn)換功能
private static void add(Test test){
   Test integerTest = (Test)test;
}

Java泛型instanceof運(yùn)算符

因?yàn)榫幾g器使用類型擦除，運(yùn)行時(shí)不會(huì)跟蹤類型參數(shù)，所以在Test 和Test 之間的運(yùn)行時(shí)差異無(wú)法使用instanceOf運(yùn)算符進(jìn)行驗(yàn)證。

Java泛型不能使用異常

泛型類不允許直接或間接擴(kuò)展Throwable類。

//The generic class Test may not subclass java.lang.Throwable
class Test extends Exception {}
//The generic class Test1 may not subclass java.lang.Throwable
class Test1 extends Throwable {}

在一個(gè)方法中，不允許捕獲一個(gè)類型參數(shù)的實(shí)例，但throws子句中允許使用類型參數(shù)。

public static  
   void execute(List jobs) {
      try {
         for (J job : jobs){}

         // compile-time error
         //Cannot use the type parameter T in a catch block
      } catch (T e) { 
         // ...
   }
}

//
class Test  {
   private int t;

   public void add(int t) throws T {
      this.t = t;
   }
   public int get() {
      return t;
   }   
}

Java泛型不能使用數(shù)組

錯(cuò)誤代碼

//Cannot create a generic array of Test
Test[] arrayOfLists = new Test[2];

因?yàn)榫幾g器使用類型擦除，類型參數(shù)被替換為Object，用戶可以向數(shù)組添加任何類型的對(duì)象。但在運(yùn)行時(shí)，代碼將無(wú)法拋出ArrayStoreException。

下面使用Sun的一篇文檔的一個(gè)例子來(lái)說(shuō)明這個(gè)問(wèn)題：

List[] lsa = new List[10]; // Not really allowed.    
Object o = lsa;    
Object[] oa = (Object[]) o;    
List li = new ArrayList();    
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泛型的擦除機(jī)制，在運(yùn)行時(shí)JVM是不知道泛型信息的，所以可以給oa[1]賦上一個(gè)ArrayList而不會(huì)出現(xiàn)異常，但是在取出數(shù)據(jù)的時(shí)候卻要做一次類型轉(zhuǎn)換，所以就會(huì)出現(xiàn)ClassCastException，如果可以進(jìn)行泛型數(shù)組的聲明，上面說(shuō)的這種情況在編譯期將不會(huì)出現(xiàn)任何的警告和錯(cuò)誤，只有在運(yùn)行時(shí)才會(huì)出錯(cuò)。而對(duì)泛型數(shù)組的聲明進(jìn)行限制，對(duì)于這樣的情況，可以在編譯期提示代碼有類型安全問(wèn)題，比沒(méi)有任何提示要強(qiáng)很多。
下面采用通配符的方式是被允許的:數(shù)組的類型不可以是類型變量，除非是采用通配符的方式，因?yàn)閷?duì)于通配符的方式，最后取出數(shù)據(jù)是要做顯式的類型轉(zhuǎn)換的。

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

Java泛型不能重載

一個(gè)類不允許有兩個(gè)重載方法，可以在類型擦除后使用相同的簽名。

類型擦除

Java編譯器應(yīng)用類型擦除。類型擦除是指編譯器使用實(shí)際的類或橋接方法替換泛型參數(shù)的過(guò)程。在類型擦除中，編譯器確保不會(huì)創(chuàng)建額外的類，并且沒(méi)有運(yùn)行時(shí)開(kāi)銷。

Java編譯器編譯泛型的步驟：

檢查泛型的類型，獲得目標(biāo)類型

擦除類型變量，并替換為限定類型（T為無(wú)限定的類型變量，用Object替換）

調(diào)用相關(guān)函數(shù)，并將結(jié)果強(qiáng)制轉(zhuǎn)換為目標(biāo)類型。

 ArrayList arrayString=new ArrayList();     
 ArrayList arrayInteger=new ArrayList();     
 System.out.println(arrayString.getClass()==arrayInteger.getClass());

上面代碼輸入結(jié)果為 true，可見(jiàn)通過(guò)運(yùn)行時(shí)獲取的類信息是完全一致的，泛型類型被擦除了！

如何擦除：
當(dāng)擦除泛型類型后，留下的就只有原始類型了，例如上面的代碼，原始類型就是ArrayList。擦除類型變量，并替換為限定類型（T為無(wú)限定的類型變量，用Object替換），如下所示

擦除之前：

//泛型類型  
class Pair {    
    private T value;    
    public T getValue() {    
        return value;    
    }    
    public void setValue(T  value) {    
        this.value = value;    
    }    
}

擦除之后：

//原始類型  
class Pair {    
    private Object value;    
    public Object getValue() {    
        return value;    
    }    
    public void setValue(Object  value) {    
        this.value = value;    
    }    
}

因?yàn)樵?b>Pair中，T是一個(gè)無(wú)限定的類型變量，所以用Object替換。如果是Pair，擦除后，類型變量用Number類型替換。

如果要死磕Java泛型內(nèi)部原理，請(qǐng)參考文章泛型的內(nèi)部原理：類型擦除以及類型擦除帶來(lái)的問(wèn)題、Java泛型深入了解

總結(jié)

在使用泛型類時(shí)，由于 Java 泛型的類型參數(shù)之實(shí)際類型在編譯時(shí)會(huì)被消除，所以無(wú)法在運(yùn)行時(shí)得知其類型參數(shù)的類型。雖然傳入了不同的泛型實(shí)參，但并沒(méi)有真正生成不同的類型，傳入不同泛型實(shí)參的泛型類在內(nèi)存上實(shí)際只有一個(gè)，但在邏輯上，我們可以理解為多個(gè)不同的泛型類型。

參考文章

https://blog.csdn.net/s10461/...

https://www.cnblogs.com/lwbqq...

https://www.cnblogs.com/iyang...

GPU云服務(wù)器云服務(wù)器 java 泛型 java.泛型泛型java java泛型

文章版權(quán)歸作者所有，未經(jīng)允許請(qǐng)勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請(qǐng)注明本文地址：http://systransis.cn/yun/74778.html

發(fā)表評(píng)論

登陸后可評(píng)論

0條評(píng)論

godiscoder

男|高級(jí)講師

我要關(guān)注我要私信

TA的文章

軟件工程的10個(gè)知識(shí)領(lǐng)域

閱讀 3306·2021-09-02 15:41
取消大小周后首次發(fā)薪，字節(jié)跳動(dòng)員工炸了：薪資普降17%！

閱讀 2839·2021-09-02 09:48
[Sass]-Sass入門

閱讀 1379·2019-08-29 13:27
盤點(diǎn)一下Javascript的那些隱式轉(zhuǎn)換

閱讀 1169·2019-08-26 13:37
Babylon-AST初探-實(shí)戰(zhàn)

閱讀 844·2019-08-26 11:56
vue中利用混入定義全局變量、函數(shù)、篩選器

閱讀 2490·2019-08-26 10:24
history和hash，vue-router

閱讀 1651·2019-08-23 18:07
前端prerender-spa-plugin預(yù)渲染

閱讀 2625·2019-08-23 15:16

成人国产在线小视频_日韩寡妇人妻调教在线播放_色成人www永久在线观看_2018国产精品久久_亚洲欧美高清在线30p_亚洲少妇综合一区_黄色在线播放国产_亚洲另类技巧小说校园_国产主播xx日韩_a级毛片在线免费

資訊專欄INFORMATION COLUMN

上云采購(gòu)季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺(tái)、長(zhǎng)期優(yōu)惠，快來(lái)選購(gòu)！

淺析Java泛型

相關(guān)文章

Java相關(guān)

Java深入-框架技巧

**《java編程思想》—— 泛型**

Java知識(shí)點(diǎn)總結(jié)（Java泛型）

發(fā)表評(píng)論

0條評(píng)論

godiscoder

男|高級(jí)講師

TA的文章

軟件工程的10個(gè)知識(shí)領(lǐng)域

取消大小周后首次發(fā)薪，字節(jié)跳動(dòng)員工炸了：薪資普降17%！

[Sass]-Sass入門

盤點(diǎn)一下Javascript的那些隱式轉(zhuǎn)換

Babylon-AST初探-實(shí)戰(zhàn)

vue中利用混入定義全局變量、函數(shù)、篩選器

history和hash，vue-router

前端prerender-spa-plugin預(yù)渲染

最新活動(dòng)

資訊專欄INFORMATION COLUMN

上云采購(gòu)季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺(tái)、長(zhǎng)期優(yōu)惠，快來(lái)選購(gòu)！

淺析Java泛型

相關(guān)文章

發(fā)表評(píng)論

0條評(píng)論

男|高級(jí)講師

TA的文章

最新活動(dòng)

上云采購(gòu)季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺(tái)、長(zhǎng)期優(yōu)惠，快來(lái)選購(gòu)！