2. 程式人生 > >java基礎-泛型詳解(1):基本使用

java基礎-泛型詳解(1):基本使用

阿新 • • 發佈：2019-01-01

前言：無論何時，相信自己。

相關文章：

一、引入

1、泛型是什麼

首先告訴大家ArrayList就是泛型。那ArrayList能完成哪些想不到的功能呢？先看看下面這段程式碼：
  1. ArrayList<String> strList = new ArrayList<String>();  
  2. ArrayList<Integer> intList = new ArrayList<Integer>();  
  3. ArrayList<Double> doubleList = new ArrayList<Double>();  
大家對ArrayList很熟悉，這裡構造了三個List,分別盛裝String、Integer和Double；這就是ArrayList的過人之處：即各種型別的變數都可以組裝成對應的List，而不必針對每個型別分別實現一個構建ArrayList的類。這裡可能看不懂，開篇總是困難的，下面看看如果沒有泛型的話，我們要怎麼做；

2、沒有泛型會怎樣

先看下面這段程式碼：
我們實現兩個能夠設定點座標的類，分別設定Integer型別的點座標和Float型別的點座標：
  1. //設定Integer型別的點座標
  2. class IntegerPoint{  
  3.     private Integer x ;       // 表示X座標
  4.     private Integer y ;       // 表示Y座標
  5.     publicvoid setX(Integer x){  
  6.         this.x = x ;  
  7.     }  
  8.     publicvoid setY(Integer y){  
  9.         this.y = y ;  
  10.     }  
  11.     public
     Integer getX(){  
  12.         returnthis.x ;  
  13.     }  
  14.     public Integer getY(){  
  15.         returnthis.y ;  
  16.     }  
  17. }  
  18. //設定Float型別的點座標
  19. class FloatPoint{  
  20.     private Float x ;       // 表示X座標
  21.     private Float y ;       // 表示Y座標
  22.     publicvoid setX(Float x){  
  23.         this.x = x ;  
  24.     }  
  25.     publicvoid setY(Float y){  
  26.         this.y = y ;  
  27.     }  
  28.     public Float getX(){  
  29.         returnthis.x ;  
  30.     }  
  31.     public Float getY(){  
  32.         returnthis.y ;  
  33.     }  
  34. }  
那現在有個問題：大家有沒有發現，他們除了變數型別不一樣，一個是Integer一個是Float以外，其它並沒有什麼區別！那我們能不能合併成一個呢？
答案是可以的，因為Integer和Float都是派生自Object的，我們用下面這段程式碼代替：
  1. class ObjectPoint{  
  2.     private Object x ;  
  3.     private Object y ;  
  4.     publicvoid setX(Object x){  
  5.         this.x = x ;  
  6.     }  
  7.     publicvoid setY(Object y){  
  8.         this.y = y ;  
  9.     }  
  10.     public Object getX(){  
  11.         returnthis.x ;  
  12.     }  
  13.     public Object getY(){  
  14.         returnthis.y ;  
  15.     }  
  16. }  
即全部都用Object來代替所有的子類；
在使用的時候是這樣的：
  1. ObjectPoint integerPoint = new ObjectPoint();  
  2. integerPoint.setX(new Integer(100));  
  3. Integer integerX=(Integer)integerPoint.getX();  
在設定的時候，使用new Integer(100)來新建一個Integer
  1. integerPoint.setX(new Integer(100));  
然後在取值的時候，進行強制轉換：
  1. Integer integerX=(Integer)integerPoint.getX();  
由於我們設定的時候，是設定的Integer，所以在取值的時候，強制轉換是不會出錯的。
同理，FloatPoint的設定和取值也是類似的，程式碼如下：
  1. ObjectPoint floatPoint = new ObjectPoint();  
  2. floatPoint.setX(new Float(100.12f));  
  3. Float floatX = (Float)floatPoint.getX();  
但問題來了：注意，注意，我們這裡使用了強制轉換，我們這裡setX（）和getX（）寫得很近，所以我們明確的知道我們傳進去的是Float型別，那如果我們記錯了呢？
比如我們改成下面這樣，編譯時會報錯嗎：
  1. ObjectPoint floatPoint = new ObjectPoint();  
  2. floatPoint.setX(new Float(100.12f));  
  3. String floatX = (String)floatPoint.getX();  
不會！！！我們問題的關鍵在於這句：
  1. String floatX = (String)floatPoint.getX();  
強制轉換時，會不會出錯。因為編譯器也不知道你傳進去的是什麼，而floatPoint.getX()返回的型別是Object，所以編譯時，將Object強轉成String是成立的。必然不會報錯。
而在執行時，則不然，在執行時，floatPoint例項中明明傳進去的是Float型別的變數，非要把它強轉成String型別，肯定會報型別轉換錯誤的！
那有沒有一種辦法在編譯階段，即能合併成同一個，又能在編譯時檢查出來傳進去型別不對呢？當然，這就是泛型。
下面我們將對泛型的寫法和用法做一一講解。

二、各種泛型定義及使用

1、泛型類定義及使用

我們先看看泛型的類是怎麼定義的：
  1. //定義
  2. class Point<T>{// 此處可以隨便寫識別符號號 
  3.     private T x ;        
  4.     private T y ;        
  5.     publicvoid setX(T x){//作為引數
  6.         this.x = x ;  
  7.     }  
  8.     publicvoid setY(T y){  
  9.         this.y = y ;  
  10.     }  
  11.     public T getX(){//作為返回值
  12.         returnthis.x ;  
  13.     }  
  14.     public T getY(){  
  15.         returnthis.y ;  
  16.     }  
  17. };  
  18. //IntegerPoint使用
  19. Point<Integer> p = new Point<Integer>() ;   
  20. p.setX(new Integer(100)) ;   
  21. System.out.println(p.getX());    
  22. //FloatPoint使用
  23. Point<Float> p = new Point<Float>() ;   
  24. p.setX(new Float(100.12f)) ;   
  25. System.out.println(p.getX());    
先看看執行結果：

從結果中可以看到，我們實現了開篇中IntegerPoint類和FloatPoint類的效果。下面來看看泛型是怎麼定義及使用的吧。

（1）、定義泛型：Point<T>
首先，大家可以看到Point<T>，即在類名後面加一個尖括號，括號裡是一個大寫字母。這裡寫的是T，其實這個字母可以是任何大寫字母，大家這裡先記著，可以是任何大寫字母，意義是相同的。
（2）類中使用泛型
這個T表示派生自Object類的任何類，比如String,Integer,Double等等。這裡要注意的是，T一定是派生於Object類的。為方便起見，大家可以在這裡把T當成String,即String在類中怎麼用，那T在類中就可以怎麼用！所以下面的：定義變數，作為返回值，作為引數傳入的定義就很容易理解了。

  1. //定義變數
  2. private T x ;   
  3. //作為返回值
  4. public T getX(){   
  5.     return x ;    
  6. }    
  7. //作為引數
  8. publicvoid setX(T x){    
  9.     this.x = x ;    
  10. }   
（3）使用泛型類
下面是泛型類的用法：
  1. //IntegerPoint使用
  2. Point<Integer> p = new Point<Integer>() ;   
  3. p.setX(new Integer(100)) ;   
  4. System.out.println(p.getX());    
  5. //FloatPoint使用
  6. Point<Float> p = new Point<Float>() ;   
  7. p.setX(new Float(100.12f)) ;   
  8. System.out.println(p.getX());    
首先，是構造一個例項：
  1. Point<String> p = new Point<String>() ;   
這裡與普通構造類例項的不同之點在於，普通類建構函式是這樣的：Point p = new Point() ;
而泛型類的構造則需要在類名後新增上<String>，即一對尖括號，中間寫上要傳入的型別。
因為我們構造時，是這樣的：class Point<T>,所以在使用的時候也要在Point後加上型別來定義T代表的意義。
然後在getVar（）和setVar（）時就沒有什麼特殊的了，直接呼叫即可。
從上面的使用時，明顯可以看出泛型的作用，在構造泛型類的例項的時候：
  1. //IntegerPoint使用
  2. Point<Integer> p = new Point<Integer>() ;   
  3. //FloatPoint使用
  4. Point<Float> p = new Point<Float>() ;   
尖括號中，你傳進去的是什麼，T就代表什麼型別。這就是泛型的最大作用，我們只需要考慮邏輯實現，就能拿給各種類來用。
前面我們提到ArrayList也是泛型，我們順便它的實現：
  1. publicclass ArrayList<E>{  
  2.     …………  
  3. }  
看到了吧，跟我們的Point實現是一樣的，這也就是為什麼ArrayList能夠盛裝各種型別的主要原因。
(4）使用泛型實現的優勢
相比我們開篇時使用Object的方式，有兩個優點：
（1）、不用強制轉換
  1. //使用Object作為返回值，要強制轉換成指定型別
  2. Float floatX = (Float)floatPoint.getX();  
  3. //使用泛型時，不用強制轉換，直接出來就是String
  4. System.out.println(p.getVar());   
(2)、在settVar()時如果傳入型別不對，編譯時會報錯

可以看到，當我們構造時使用的是String,而在setVar時，傳進去Integer型別時，就會報錯。而不是像Object實現方式一樣，在執行時才會報強制轉換錯誤。

2、多泛型變數定義及字母規範

（1）、多泛型變數定義
上在我們只定義了一個泛型變數T，那如果我們需要傳進去多個泛型要怎麼辦呢？
只需要在類似下面這樣就可以了：
  1. class MorePoint<T,U>{  
  2. }  
也就是在原來的T後面用逗號隔開，寫上其它的任意大寫字母即可。想加幾個就加幾個，比如我們想加五個泛型變數，那應該是這樣的：
  1. class MorePoint<T,U,A,B,C>{  
  2. }  
舉個粟子，我們在Point上再另加一個欄位name，也用泛型來表示，那要怎麼做？程式碼如下：
  1. class MorePoint<T,U> {  
  2.     private T x;  
  3.     private T y;         
  4.     private U name;  
  5.     publicvoid setX(T x) {  
  6.         this.x = x;  
  7.     }  
  8.     public T getX() {  
  9.         returnthis.x;  
  10.     }  
  11.     …………  
  12.     publicvoid setName(U name){  
  13.         this.name = name;  
  14.     }  
  15.     public U getName() {  
  16.         returnthis.name;  
  17.     }  
  18. }  
  19. //使用
  20. MorePoint<Integer,String> morePoint = new MorePoint<Integer, String>();  
  21. morePoint.setName("harvic");  
  22. Log.d(TAG, "morPont.getName:" + morePoint.getName());  
從上面的程式碼中，可以明顯看出，就是在新新增的泛型變數U用法與T是一樣的。
（2）、字母規範
在定義泛型類時，我們已經提到用於指定泛型的變數是一個大寫字母：
  1. class Point<T>{  
  2.  …………  
  3. }  
當然不是的！！！！任意一個大寫字母都可以。他們的意義是完全相同的，但為了提高可讀性，大家還是用有意義的字母比較好，一般來講，在不同的情境下使用的字母意義如下：
  •  E — Element，常用在java Collection裡，如：List<E>,Iterator<E>,Set<E>
  •  K,V — Key，Value，代表Map的鍵值對
  •  N — Number，數字
  •  T — Type，型別，如String，Integer等等
如果這些還不夠用，那就自己隨便取吧，反正26個英文字母呢。
再重複一遍，使用哪個字母是沒有特定意義的！只是為了提高可讀性！！！！

3、泛型介面定義及使用

在介面上定義泛型與在類中定義泛型是一樣的，程式碼如下：

  1. interface Info<T>{        // 在介面上定義泛型  
  2.     public T getVar() ; // 定義抽象方法，抽象方法的返回值就是泛型型別  
  3.     publicvoid setVar(T x);  
  4. }    

與泛型類的定義一樣，也是在介面名後加尖括號；
（1）、使用方法一：非泛型類
但是在使用的時候，就出現問題了，我們先看看下面這個使用方法：

  1. class InfoImpl implements Info<String>{   // 定義泛型介面的子類
  2.     private String var ;                // 定義屬性
  3.     public InfoImpl(String var){        // 通過構造方法設定屬性內容
  4.         this.setVar(var) ;  
  5.     }  
  6.     @Override
  7.     publicvoid setVar(String var){  
  8.         this.var = var ;  
  9.     }  
  10.     @Override
  11.     public String getVar(){  
  12.         returnthis.var ;  
  13.     }  
  14. }  
  15. publicclass GenericsDemo24{  
  16.     publicvoid main(String arsg[]){  
  17.         InfoImpl i = new InfoImpl("harvic");  
  18.         System.out.println(i.getVar()) ;  
  19.     }  
  20. };  
首先，先看InfoImpl的定義：
  1. class InfoImpl implements Info<String>{     
  2.  …………  
  3. }  
要清楚的一點是InfoImpl不是一個泛型類！因為他類名後沒有<T>！
然後在在這裡我們將Info<String>中的泛型變數T定義填充為了String型別。所以在重寫時setVar（）和getVar（）時，IDE會也我們直接生成String型別的重寫函式。
最後在使用時,沒什麼難度，傳進去String型別的字串來構造InfoImpl例項，然後呼叫它的函式即可。
  1. publicclass GenericsDemo24{  
  2.     publicvoid main(String arsg[]){  
  3.         InfoImpl i = new InfoImpl("harvic");  
  4.         System.out.println(i.getVar()) ;  
  5.     }  
  6. };  
（2）、使用方法二：泛型類

在方法一中，我們在類中直接把Info<T>介面給填充好了，但我們的類，是可以構造成泛型類的，那我們利用泛型類來構造填充泛型介面會是怎樣呢？

  1. interface Info<T>{        // 在介面上定義泛型
  2.     public T getVar() ; // 定義抽象方法，抽象方法的返回值就是泛型型別
  3.     publicvoid setVar(T var);  
  4. }  
  5. class InfoImpl<T> implements Info<T>{   // 定義泛型介面的子類
  6.     private T var ;             // 定義屬性
  7.     public InfoImpl(T var){     // 通過構造方法設定屬性內容
  8.         this.setVar(var) ;    
  9.     }  
  10.     publicvoid setVar(T var){  
  11.         this.var = var ;  
  12.     }  
  13.     public T getVar(){  
  14.         returnthis.var ;  
  15.     }  
  16. }  
  17. publicclass GenericsDemo24{  
  18.     publicstaticvoid main(String arsg[]){  
  19.         InfoImpl<String> i = new InfoImpl<String>("harvic");  
  20.         System.out.println(i.getVar()) ;  
  21.     }  
  22. };  
最關鍵的是構造泛型類的過程：
  1. class InfoImpl<T> implements Info<T>{   // 定義泛型介面的子類
  2.     private T var ;             // 定義屬性
  3.     public InfoImpl(T var){     // 通過構造方法設定屬性內容
  4.         this.setVar(var) ;    
  5.     }  
  6.     publicvoid setVar(T var){  
  7.         this.var = var ;  
  8.     }  
  9.     public T getVar(){  
  10.         returnthis.var ;  
  11.     }  
  12. }  
在這個類中，我們構造了一個泛型類InfoImpl<T>，然後把泛型變數T傳給了Info<T>，這說明介面和泛型類使用的都是同一個泛型變數。
然後在使用時，就是構造一個泛型類的例項的過程，使用過程也不變。
  1. publicclass GenericsDemo24{  
  2.     publicstaticvoid main(String arsg[]){  
  3.         Info<String> i = new InfoImpl<String>("harvic");  
  4.         System.out.println(i.getVar()) ;  
  5.     }  
  6. };  
使用泛型類來繼承泛型介面的作用就是讓使用者來定義介面所使用的變數型別，而不是像方法一那樣，在類中寫死。
那我們稍微加深點難度，構造一個多個泛型變數的類，並繼承自Info介面：
  1. class InfoImpl<T,K,U> implements Info<U>{   // 定義泛型介面的子類
  2.      private U var ;      
  3.      private T x;  
  4.      private K y;  
  5.      public InfoImpl(U var){        // 通過構造方法設定屬性內容
  6.          this.setVar(var) ;  
  7.      }  
  8.      publicvoid setVar(U var){  
  9.          this.var = var ;  
  10.      }  
  11.      public U getVar(){  
  12.          returnthis.var ;  
  13.      }  
  14.  }  
在這個例子中，我們在泛型類中定義三個泛型變數T,K,U並且把第三個泛型變數U用來填充介面Info。所以在這個例子中Info所使用的型別就是由U來決定的。
使用時是這樣的：泛型類的基本用法，不再多講,程式碼如下：
  1. publicclass GenericsDemo24{  
  2.     publicvoid main(String arsg[]){  
  3.         InfoImpl<Integer,Double,String> i = new InfoImpl<Integer,Double,String>("harvic");  
  4.         System.out.println(i.getVar()) ;  
  5.     }  
  6. }  

4、泛型函式定義及使用

上面我們講解了類和介面的泛型使用，下面我們再說說，怎麼單獨在一個函式裡使用泛型。比如我們在新建一個普通的類StaticFans，然後在其中定義了兩個泛型函式：
  1. publicclass StaticFans {  
  2.     //靜態函式
  3.     publicstatic  <T> void StaticMethod(T a){  
  4.         Log.d("harvic","StaticMethod: "+a.toString());  
  5.     }  
  6.     //普通函式
  7.     public  <T> void OtherMethod(T a){  
  8.         Log.d("harvic","OtherMethod: "+a.toString());  
  9.     }  
  10. }  
上面分別是靜態泛型函式和常規泛型函式的定義方法，與以往方法的唯一不同點就是在返回值前加上<T>來表示泛型變數。其它沒什麼區別。
使用方法如下：
  1. //靜態方法
  2. StaticFans.StaticMethod("adfdsa");//使用方法一
  3. StaticFans.<String>StaticMethod("adfdsa");//使用方法二
  4. //常規方法
  5. StaticFans staticFans = new StaticFans();  
  6. staticFans.OtherMethod(new Integer(123));//使用方法一
  7. staticFans.<Integer>OtherMethod(new Integer(123));//使用方法二
結果如下：

首先，我們看靜態泛型函式的使用方法：

  1. StaticFans.StaticMethod("adfdsa");//使用方法一
  2. StaticFans.<String>StaticMethod("adfdsa");//使用方法二
從結果中我們可以看到，這兩種方法的結果是完全一樣的，但他們還有些區別的，區別如下：
方法一，可以像普通方法一樣，直接傳值，任何值都可以（但必須是派生自Object類的型別，比如String,Integer等），函式會在內部根據傳進去的引數來識別當前T的類別。但儘量不要使用這種隱式的傳遞方式，程式碼不利於閱讀和維護。因為從外觀根本看不出來你呼叫的是一個泛型函式。
方法二，與方法一不同的地方在於，在呼叫方法前加了一個<String>來指定傳給<T>的值，如果加了這個<String>來指定引數的值的話，那StaticMethod（）函式裡所有用到的T型別也就是強制指定了是String型別。這是我們建議使用的方式。
同樣，常規泛型函式的使用也有這兩種方式：
  1. StaticFans staticFans = new StaticFans();  
  2. staticFans.OtherMethod(new Integer(123));//使用方法一
  3. staticFans.<Integer>OtherMethod(new Integer(123));//使用方法二
可以看到，與平常一樣，先建立類的例項，然後呼叫泛型函式。
方法一，隱式傳遞了T的型別，與上面一樣，不建議這麼做。
方法二，顯示將T賦值為Integer型別，這樣OtherMethod（T a）傳遞過來的引數如果不是Integer那麼編譯器就會報錯。

進階：返回值中存在泛型
上面我們的函式中，返回值都是void，但現實中不可能都是void，有時，我們需要將泛型變數返回，比如下面這個函式：
  1. publicstatic <T> List<T> parseArray(String response,Class<T> object){  
  2.     List<T> modelList = JSON.parseArray(response, object);  
  3.     return modelList;  
  4. }  
函式返回值是List<T>型別。至於傳入引數Class<T> object的意義，我們下面會講。這裡也就是想通過這個例子來告訴大家，泛型變數其實跟String,Integer，Double等等的類的使用上沒有任何區別，T只是一個符號，可以代表String,Integer，Double……這些類的符號，在泛型函式使用時，直接把T看到String,Integer，Double……中的任一個來寫程式碼就可以了。唯一不同的是，要在函式定義的中在返回值前加上<T>標識泛型；

5、其它用法:Class<T>類傳遞及泛型陣列

（1）、使用Class<T>傳遞泛型類Class物件
有時，我們會遇到一個情況，比如，我們在使用JSON解析字串的時候，程式碼一般是這樣的
  1. publicstatic List<SuccessModel> parseArray(String response){  
  2.     List<SuccessModel> modelList = JSON.parseArray(response, SuccessModel.class);  
  3.     return modelList;  
  4. }  
其中SuccessModel是自定義的解析類，程式碼如下，其實大家不用管SuccessModel的定義，只考慮上面的那段程式碼就行了。寫出來SuccessModel的程式碼，只是不想大家感到迷惑，其實，這裡只是fastJson的基本用法而已。
這段程式碼的意義就是根據SuccessModel解析出List<SuccessModel>的陣列。
  1. publicclass SuccessModel {  
  2.     privateboolean success;  
  3.     publicboolean isSuccess() {  
  4.         return success;  
  5.     }  
  6.     publicvoid setSuccess(boolean success) {  
  7.         this.success = success;  
  8.     }  
  9. }   
那現在，我們把下面這句組裝成一個泛型函式要怎麼來做呢?
  1. publicstatic List<SuccessModel> parseArray(String response){  
  2.     List<SuccessModel> modelList = JSON.parseArray(response, SuccessModel.class);  
  3.     return modelList;  
  4. }  
首先，我們應該把SuccessModel單獨抽出來做為泛型變數，但parseArray（）中用到的SuccessModel.class要怎麼弄呢？
先來看程式碼：
  1. publicstatic <T> List<T> parseArray(String response,Class<T> object){  
  2.     List<T> modelList = JSON.parseArray(response, object);  
  3.     return modelList;  
  4. }  
注意到，我們用的Class<T> object來傳遞類的class物件，即我們上面提到的SuccessModel.class。
這是因為Class<T>也是一泛型，它是傳來用來裝載類的class物件的，它的定義如下：
  1. publicfinalclass Class<T> implements Serializable {  
  2.     …………  
  3. }  
通過Class<T>來載入泛型的Class物件的問題就講完了，下面來看看泛型陣列的使用方法吧。
（2）、定義泛型陣列
在寫程式時，大家可能會遇到類似String[] list = new String[8];的需求，這裡可以定義String陣列，當然我們也可以定義泛型陣列，泛型陣列的定義方法為 T[]，與String[]是一致的，下面看看用法：
  1. //定義
  2. publicstatic <T> T[] fun1(T...arg){  // 接收可變引數  
  3.        return arg ;            // 返回泛型陣列  
  4. }    
  5. //使用
  6. publicstaticvoid main(String args[]){    
  7.        Integer i[] = fun1(1,2,3,4,5,6) ;  
  8.        Integer[] result = fun1(i) ;  
  9. }    
我們先看看 定義時的程式碼：
  1. publicstatic <T> T[] fun1(T...arg){  // 接收可變引數  
  2.        return arg ;            // 返回泛型陣列  
  3. }    
首先，定義了一個靜態函式，然後定義返回值為T[]，引數為接收的T型別的可變長引數。如果有同學對T...arg的用法不瞭解，可以去找下JAVA 可變長引數方面的知識。
由於可變長引數在輸入後，會儲存在arg這個陣列中，所以，我們直接把陣列返回即可。

好了，這篇到這裡就結束了，這篇中主要講述了泛型在各方面的定義及用法，下篇，我們將講述，有關泛型限定相關的知識。

如果本文有幫到你，記得加關注哦

相關推薦

java基礎-泛型詳解(1):基本使用

前言：無論何時，相信自己。 相關文章： 一、引入 1、泛型是什麼 首先告訴大家ArrayList就是泛型。那ArrayList能完成哪些想不到的功能呢？先看看下面這段程式碼： ArrayList<String> strList = new ArrayList<String>(

夯實JAVA基本之一 —— 泛型詳解(1):基本使用

前言：無論何時，相信自己。相關文章：一、引入1、泛型是什麼首先告訴大家ArrayList就是泛型。那ArrayList能完成哪些想不到的功能呢？先看看下面這段程式碼：ArrayList<String> strList = new ArrayList<Stri

Java的泛型詳解(一)

# Java的泛型詳解 ## 泛型的好處 * 編寫的程式碼可以被不同型別的物件所重用。 * 因為上面的一個優點，泛型也可以減少程式碼的編寫。 ## 泛型的使用 ### 簡單泛型類 ```java public class Pair { private T first; priv

[JAVA基礎] 十一、泛型詳解

一. 泛型概念的提出（為什麼需要泛型）？ 首先，我們看下下面這段簡短的程式碼: public class GenericTest { public static void main(String[] args) { List list = n

Java泛型詳解

對象數組 整形 泛型方法 tty 接受 一個 div -m color 泛型的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數。 假定我們有這樣一個需求：寫一個排序方法，能夠對整形數組、字符串數組甚至其他任何類型的數組進行排序，該如何實現？ 答案是可以使用 Ja

Java技術——Java泛型詳解（轉）

cal 5.1 try 既然 參數 top 兩種 泛型編程 編譯器 1．為什麽需要泛型轉載請註明出處：http://blog.csdn.net/seu_calvin/article/details/52230032泛型在Java中有很重要的地位，網上很多文章羅列各種理論，不

java 泛型詳解-絕對是對泛型方法講解最詳細的，沒有之一

對java的泛型特性的瞭解僅限於表面的淺淺一層，直到在學習設計模式時發現有不瞭解的用法，才想起詳細的記錄一下。 本文參考java 泛型詳解、Java中的泛型方法、 java泛型詳解 1. 概述 泛型在java中有很重要的地位，在面向物件程式設計及各種設計模式中有非常廣泛

Java 泛型詳解

一、概述 泛型，即“引數化型別”。一提到引數，最熟悉的就是定義方法時有形參，然後呼叫此方法時傳遞實參。那麼引數化型別怎麼理解呢？ 顧名思義，就是將型別由原來的具體的型別引數化，類似於方法中的變數引數，此時型別也定義成引數形式（可以稱之為型別形參）， 然後在

java泛型詳解和反射泛型通用BaseDao實現

一 泛型的基本概念 1.1什麼是泛型？ 泛型，即“引數化型別”。一提到引數，最熟悉的就是定義方法時有形參，然後呼叫此方法時傳遞實參。那麼引數化型別怎麼理解呢？顧名思義，就是將型別由原來的具體的型別引數化，類似於方法中的變數引數，此時型別也定義成引數形式（可以

最詳細的java泛型詳解

對java的泛型特性的瞭解僅限於表面的淺淺一層，直到在學習設計模式時發現有不瞭解的用法，才想起詳細的記錄一下。 本文參考java 泛型詳解、Java中的泛型方法、 java泛型詳解 1. 概述 泛型在java中有很重要的地位，在面向物件程式設計及各種設計模式中有非常廣泛的應用。 什麼是泛型？為什麼要使用泛型

Java泛型詳解(透徹)

amp pan 同時 dog extend dem get方法 多個 條件 定義 Java中的泛型在JavaSE5中引入。所謂泛型，即參數化類型。就是說，類型是以參數的方式傳入泛型類。例如： ArrayList<Integer> aaryList = new

java 泛型詳解（普通泛型、 萬用字元、 泛型介面，泛型陣列，泛型方法，泛型巢狀）

JDK1.5 令我們期待很久,可是當他釋出的時候卻更換版本號為5.0。這說明Java已經有大幅度的變化。本文將講解JDK5.0支援的新功能-----Java的泛型. 1、Java泛型  其實Java

C# 泛型詳解

安全 c++ urn 操作 類型 增加 add 應用 定義 什麽是泛型 我們在編寫程序時，經常遇到兩個模塊的功能非常相似，只是一個是處理int數據，另一個是處理string數據，或者其他自定義的數據類型，但我們沒有辦法，只能分別寫多個方法處理每個數據類型，因為

Java基礎——泛型

com get java 通配符 str ges test public 註意 轉http://www.cnblogs.com/1693977889zz/p/7095460.html 一、定義 泛型（generic）是指參數化類型的能力。可以定義帶泛型類型的類或方法，隨後編

Java 基礎 -- 泛型、集合、IO、反射

array ger read let input 處理 chm 媒體 files 計劃把 Java 基礎的有些部分再次看一遍，鞏固一下，下面以及以後就會分享自己再次學習的一點筆記！不是有關標題的所有知識點，只是自己覺得模糊的一些知識點。 1.　　對於泛型類而言，你若沒有指明

[泛型]C# 之泛型詳解

如果 runtime 表現 log 都是 元數據 訪問 全面 compare 什麽是泛型 我們在編寫程序時，經常遇到兩個模塊的功能非常相似，只是一個是處理int數據，另一個是處理string數據，或者其他自定義的數據類型，但我們沒有辦法，只能分別寫

c#之泛型詳解

ring 獲取 更改 9.png 主題 efault 出現 方案 泛型接口 這篇文章主要來講講c#中的泛型，因為泛型在c#中有很重要的位置，對於寫出高可讀性，高性能的代碼有著關鍵的作用。 一、什麽是泛型？ 泛型是 2.0 版 C# 語言和公共語言運行庫 (CLR) 中的一個

java基礎-泛型/萬用字元

泛型 泛型的意義： a:可以對型別進行自動檢查。 並不是替換，只是編譯期間進行檢查。 b:自動對型別進行轉換。 泛型到底是怎麼編譯的？ 型別的擦除機制：》向上擦除》Object(最高到) 在編譯器編譯期間，把泛型全部擦除為object型別。 用jmap命

【java基礎】++ -- 運算子詳解

++ -- 運算子詳解 ## 關於自增自減運算的問題《java程式設計思想》中是這樣說的： a、（i++，i--）運算子在運算元後面，先賦值，再運算 b、（++i， --i）運算子在運算元前面，先運算，再賦值 例： int i = 1; System.out.println(i-- - ++

java基礎之內部類詳解

說到Java的內部類，相信會有人跟我一樣剛瞭解時有點難以理解，（本人通過一番學習也僅僅只是略知一二，但從未使用過。。。）再此總結了下個人學習所得。 內部類定義 內部類就是在一個類的內部定義的類，內部類也是一個獨立的類，在編譯時會產生相應的class檔案。如下例： cla