posts - 110, comments - 101, trackbacks - 0, articles - 7
          
	
 
BlogJava ::
首頁 ::
新隨筆 ::
聯系 ::
聚合
 ::
管理


          
		          		
	
          
	
          
		
			
          
			
          
		          		
		
			
          
				
					
	
          
		
          
			
          
				泛型的開篇實用文章
			
          
 			Posted on 2013-06-04 21:03 云云 閱讀(307) 評論(0)  編輯  收藏  
			
			


		
          
		
          

          普通泛型
          

          

          

          Java代碼 
          

          1. class Point<T>{ // 此處可以隨便寫標識符號，T是type的簡稱 
          2. private T var ; // var的類型由T指定，即：由外部指定 
          3. public T getVar(){ // 返回值的類型由外部決定 
          4. return var ; 
          5. } 
          6. public void setVar(T var){ // 設置的類型也由外部決定 
          7. this.var = var ; 
          8. } 
          9. }; 
          10. public class GenericsDemo06{ 
          11. public static void main(String args[]){ 
          12. Point<String> p = new Point<String>() ; // 里面的var類型為String類型 
          13. p.setVar("it") ; // 設置字符串 
          14. System.out.println(p.getVar().length()) ; // 取得字符串的長度 
          15. } 
          16. }; 
          17. ---------------------------------------------------------- 
          18. class Notepad<K,V>{ // 此處指定了兩個泛型類型 
          19. private K key ; // 此變量的類型由外部決定 
          20. private V value ; // 此變量的類型由外部決定 
          21. public K getKey(){ 
          22. return this.key ; 
          23. } 
          24. public V getValue(){ 
          25. return this.value ; 
          26. } 
          27. public void setKey(K key){ 
          28. this.key = key ; 
          29. } 
          30. public void setValue(V value){ 
          31. this.value = value ; 
          32. } 
          33. }; 
          34. public class GenericsDemo09{ 
          35. public static void main(String args[]){ 
          36. Notepad<String,Integer> t = null ; // 定義兩個泛型類型的對象 
          37. t = new Notepad<String,Integer>() ; // 里面的key為String，value為Integer 
          38. t.setKey("湯姆") ; // 設置第一個內容 
          39. t.setValue(20) ; // 設置第二個內容 
          40. System.out.print("姓名；" + t.getKey()) ; // 取得信息 
          41. System.out.print("，年齡；" + t.getValue()) ; // 取得信息 
          43. } 
          44. }; 
          

          通配符
          

          

          

          Java代碼 
          

          1. class Info<T>{ 
          2. private T var ; // 定義泛型變量 
          3. public void setVar(T var){ 
          4. this.var = var ; 
          5. } 
          6. public T getVar(){ 
          7. return this.var ; 
          8. } 
          9. public String toString(){ // 直接打印 
          10. return this.var.toString() ; 
          11. } 
          12. }; 
          13. public class GenericsDemo14{ 
          14. public static void main(String args[]){ 
          15. Info<String> i = new Info<String>() ; // 使用String為泛型類型 
          16. i.setVar("it") ; // 設置內容 
          17. fun(i) ; 
          18. } 
          19. public static void fun(Info<?> temp){ // 可以接收任意的泛型對象 
          20. System.out.println("內容：" + temp) ; 
          21. } 
          22. }; 
          

          受限泛型
          

          

          

          Java代碼 
          

          1. class Info<T>{ 
          2. private T var ; // 定義泛型變量 
          3. public void setVar(T var){ 
          4. this.var = var ; 
          5. } 
          6. public T getVar(){ 
          7. return this.var ; 
          8. } 
          9. public String toString(){ // 直接打印 
          10. return this.var.toString() ; 
          11. } 
          12. }; 
          13. public class GenericsDemo17{ 
          14. public static void main(String args[]){ 
          15. Info<Integer> i1 = new Info<Integer>() ; // 聲明Integer的泛型對象 
          16. Info<Float> i2 = new Info<Float>() ; // 聲明Float的泛型對象 
          17. i1.setVar(30) ; // 設置整數，自動裝箱 
          18. i2.setVar(30.1f) ; // 設置小數，自動裝箱 
          19. fun(i1) ; 
          20. fun(i2) ; 
          21. } 
          22. public static void fun(Info<? extends Number> temp){ // 只能接收Number及其Number的子類 
          23. System.out.print(temp + "、") ; 
          24. } 
          25. }; 
          26. ---------------------------------------------------------- 
          27. class Info<T>{ 
          28. private T var ; // 定義泛型變量 
          29. public void setVar(T var){ 
          30. this.var = var ; 
          31. } 
          32. public T getVar(){ 
          33. return this.var ; 
          34. } 
          35. public String toString(){ // 直接打印 
          36. return this.var.toString() ; 
          37. } 
          38. }; 
          39. public class GenericsDemo21{ 
          40. public static void main(String args[]){ 
          41. Info<String> i1 = new Info<String>() ; // 聲明String的泛型對象 
          42. Info<Object> i2 = new Info<Object>() ; // 聲明Object的泛型對象 
          43. i1.setVar("hello") ; 
          44. i2.setVar(new Object()) ; 
          45. fun(i1) ; 
          46. fun(i2) ; 
          47. } 
          48. public static void fun(Info<? super String> temp){ // 只能接收String或Object類型的泛型 
          49. System.out.print(temp + "、") ; 
          50. } 
          51. }; 
          

          泛型無法向上轉型
          

          

          

          Java代碼 
          

          1. class Info<T>{ 
          2. private T var ; // 定義泛型變量 
          3. public void setVar(T var){ 
          4. this.var = var ; 
          5. } 
          6. public T getVar(){ 
          7. return this.var ; 
          8. } 
          9. public String toString(){ // 直接打印 
          10. return this.var.toString() ; 
          11. } 
          12. }; 
          13. public class GenericsDemo23{ 
          14. public static void main(String args[]){ 
          15. Info<String> i1 = new Info<String>() ; // 泛型類型為String 
          16. Info<Object> i2 = null ; 
          17. i2 = i1 ; //這句會出錯 incompatible types 
          18. } 
          19. }; 
          

          泛型接口
          

          

          

          Java代碼 
          

          1. interface Info<T>{ // 在接口上定義泛型 
          2. public T getVar() ; // 定義抽象方法，抽象方法的返回值就是泛型類型 
          3. } 
          4. class InfoImpl<T> implements Info<T>{ // 定義泛型接口的子類 
          5. private T var ; // 定義屬性 
          6. public InfoImpl(T var){ // 通過構造方法設置屬性內容 
          7. this.setVar(var) ; 
          8. } 
          9. public void setVar(T var){ 
          10. this.var = var ; 
          11. } 
          12. public T getVar(){ 
          13. return this.var ; 
          14. } 
          15. }; 
          16. public class GenericsDemo24{ 
          17. public static void main(String arsg[]){ 
          18. Info<String> i = null; // 聲明接口對象 
          19. i = new InfoImpl<String>("湯姆") ; // 通過子類實例化對象 
          20. System.out.println("內容：" + i.getVar()) ; 
          21. } 
          22. }; 
          23. ---------------------------------------------------------- 
          24. interface Info<T>{ // 在接口上定義泛型 
          25. public T getVar() ; // 定義抽象方法，抽象方法的返回值就是泛型類型 
          26. } 
          27. class InfoImpl implements Info<String>{ // 定義泛型接口的子類 
          28. private String var ; // 定義屬性 
          29. public InfoImpl(String var){ // 通過構造方法設置屬性內容 
          30. this.setVar(var) ; 
          31. } 
          32. public void setVar(String var){ 
          33. this.var = var ; 
          34. } 
          35. public String getVar(){ 
          36. return this.var ; 
          37. } 
          38. }; 
          39. public class GenericsDemo25{ 
          40. public static void main(String arsg[]){ 
          41. Info i = null; // 聲明接口對象 
          42. i = new InfoImpl("湯姆") ; // 通過子類實例化對象 
          43. System.out.println("內容：" + i.getVar()) ; 
          44. } 
          45. }; 
          

          泛型方法
          

          

          

          Java代碼 
          

          1. class Demo{ 
          2. public <T> T fun(T t){ // 可以接收任意類型的數據 
          3. return t ; // 直接把參數返回 
          4. } 
          5. }; 
          6. public class GenericsDemo26{ 
          7. public static void main(String args[]){ 
          8. Demo d = new Demo() ; // 實例化Demo對象 
          9. String str = d.fun("湯姆") ; // 傳遞字符串 
          10. int i = d.fun(30) ; // 傳遞數字，自動裝箱 
          11. System.out.println(str) ; // 輸出內容 
          12. System.out.println(i) ; // 輸出內容 
          13. } 
          14. }; 
          

          通過泛型方法返回泛型類型實例
          

          

          

          Java代碼 
          

          1. class Info<T extends Number>{ // 指定上限，只能是數字類型 
          2. private T var ; // 此類型由外部決定 
          3. public T getVar(){ 
          4. return this.var ; 
          5. } 
          6. public void setVar(T var){ 
          7. this.var = var ; 
          8. } 
          9. public String toString(){ // 覆寫Object類中的toString()方法 
          10. return this.var.toString() ; 
          11. } 
          12. }; 
          13. public class GenericsDemo27{ 
          14. public static void main(String args[]){ 
          15. Info<Integer> i = fun(30) ; 
          16. System.out.println(i.getVar()) ; 
          17. } 
          18. public static <T extends Number> Info<T> fun(T param){//方法中傳入或返回的泛型類型由調用方法時所設置的參數類型決定 
          19. Info<T> temp = new Info<T>() ; // 根據傳入的數據類型實例化Info 
          20. temp.setVar(param) ; // 將傳遞的內容設置到Info對象的var屬性之中 
          21. return temp ; // 返回實例化對象 
          22. } 
          23. }; 
          

          使用泛型統一傳入的參數類型
          

          

          

          Java代碼 
          

          1. class Info<T>{ // 指定上限，只能是數字類型 
          2. private T var ; // 此類型由外部決定 
          3. public T getVar(){ 
          4. return this.var ; 
          5. } 
          6. public void setVar(T var){ 
          7. this.var = var ; 
          8. } 
          9. public String toString(){ // 覆寫Object類中的toString()方法 
          10. return this.var.toString() ; 
          11. } 
          12. }; 
          13. public class GenericsDemo28{ 
          14. public static void main(String args[]){ 
          15. Info<String> i1 = new Info<String>() ; 
          16. Info<String> i2 = new Info<String>() ; 
          17. i1.setVar("HELLO") ; // 設置內容 
          18. i2.setVar("湯姆") ; // 設置內容 
          19. add(i1,i2) ; 
          20. } 
          21. public static <T> void add(Info<T> i1,Info<T> i2){ 
          22. System.out.println(i1.getVar() + " " + i2.getVar()) ; 
          23. } 
          24. }; 
          

          泛型數組
          

          

          

          Java代碼 
          

          1. public class GenericsDemo30{ 
          2. public static void main(String args[]){ 
          3. Integer i[] = fun1(1,2,3,4,5,6) ; // 返回泛型數組 
          4. fun2(i) ; 
          5. } 
          6. public static <T> T[] fun1(T...arg){ // 接收可變參數 
          7. return arg ; // 返回泛型數組 
          8. } 
          9. public static <T> void fun2(T param[]){ // 輸出 
          10. System.out.print("接收泛型數組：") ; 
          11. for(T t:param){ 
          12. System.out.print(t + "、") ; 
          13. } 
          14. } 
          15. }; 
          

          泛型的嵌套設置
          

          

          

          Java代碼 
          

          1. class Info<T,V>{ // 接收兩個泛型類型 
          2. private T var ; 
          3. private V value ; 
          4. public Info(T var,V value){ 
          5. this.setVar(var) ; 
          6. this.setValue(value) ; 
          7. } 
          8. public void setVar(T var){ 
          9. this.var = var ; 
          10. } 
          11. public void setValue(V value){ 
          12. this.value = value ; 
          13. } 
          14. public T getVar(){ 
          15. return this.var ; 
          16. } 
          17. public V getValue(){ 
          18. return this.value ; 
          19. } 
          20. }; 
          21. class Demo<S>{ 
          22. private S info ; 
          23. public Demo(S info){ 
          24. this.setInfo(info) ; 
          25. } 
          26. public void setInfo(S info){ 
          27. this.info = info ; 
          28. } 
          29. public S getInfo(){ 
          30. return this.info ; 
          31. } 
          32. }; 
          33. public class GenericsDemo31{ 
          34. public static void main(String args[]){ 
          35. Demo<Info<String,Integer>> d = null ; // 將Info作為Demo的泛型類型 
          36. Info<String,Integer> i = null ; // Info指定兩個泛型類型 
          37. i = new Info<String,Integer>("湯姆",30) ; // 實例化Info對象 
          38. d = new Demo<Info<String,Integer>>(i) ; // 在Demo類中設置Info類的對象 
          39. System.out.println("內容一：" + d.getInfo().getVar()) ; 
          40. System.out.println("內容二：" + d.getInfo().getValue()) ; 
          41. } 
          42. }; 
          

          

          泛型方法不一定要通過參數來確定泛型準確類型，可以只通過返回值，比如：
          

          public static <E> ArrayList<E> newArrayList() {
          return new ArrayList<E>();
          }
          

          

          public List<PrepaidHistory> queryHistories(Long skyid,PrepaidHistoryType type, Date from, Date end) {
          

          　　　　。。。
          return Lists.newArrayList();
          }
          

          

          這樣Lists.newArrayList();
          智能的知道返回類型為PrepaidHistory
          
	
          
	


          
	    
    




          





          


          

	
          
		
          
				
		
	
		
          
		
		
          只有注冊用戶登錄后才能發表評論。
          
		
          
			
		
          
			
		
          
		
		
          
		


          

		          		
		
          
		
          			
		
		
		
		
          
		
          
		
		
          
		
          
			網站導航:
		
		
          
		
          
			
		
          	
		
          
			 
		
          
		
          
			
		
          
		
          
			
				
		
          		
	
          	

          



          

				
			
          
		          		
	
          
	
          
		
			


		
	
          

          


    







          
        
	




主站蜘蛛池模板：
香港
|
民权县|
成武县|
安岳县|
许昌市|
孟连|
南漳县|
隆化县|
广饶县|
炉霍县|
元江|
贵南县|
清河县|
阿拉善盟|
甘孜县|
盐池县|
伽师县|
汉沽区|
灵武市|
库尔勒市|
陇西县|
岑巩县|
元阳县|
昌邑市|
拜泉县|
安西县|
虞城县|
长兴县|
探索|
石门县|
阿拉善左旗|
南投市|
随州市|
油尖旺区|
龙南县|
金昌市|
太原市|
电白县|
若尔盖县|
顺义区|
苏尼特左旗|