泛型是JDK1.5支持的新功能之一,在目前的Java編程中被廣泛的使用,下面我們就來看看泛型和它的屬性。
1、Java泛型
其實Java的泛型就是創建一個用類型作爲參數的類。就象我們寫類的方法一樣,方法是這樣的method(String str1,String str2 ),方法中參數str1、str2的值是可變的。而泛型也是一樣的,這樣寫class Java_Generics<K,V>,這裏邊的K和V就象方法中的參數str1和str2,也是可變。下面看看例子:
- //code list 1
- import Java.util.Hashtable;
- class TestGen0<K,V>{
- public Hashtable<K,V> h=new Hashtable<K,V>();
- public void put(K k, V v) {
- h.put(k,v);
- }
- public V get(K k) {
- return h.get(k);
- }
- public static void main(String args[]){
- TestGen0<String,String> t=new TestGen0<String,String>();
- t.put("key", "value");
- String s=t.get("key");
- System.out.println(s);
- }
- }
正確輸出:value
這只是個例子(Java中集合框架都泛型化了,這裏費了2遍事.),不過看看是不是創建一個用類型作爲參數的類,參數是K,V,傳入的“值”是String類型。這個類他沒有特定的待處理型別,以前我們定義好了一個類,在輸入輸入參數有所固定,是什麼型別的有要求,但是現在編寫程序,完全可以不制定參數的類型,具體用的時候來確定,增加了程序的通用性,像是一個模板。
呵呵,類似C++的模板(類似)。
1.1. 泛型通配符
下面我們先看看這些程序:
- //Code list 2
- void TestGen0Medthod1(List l) {
- for (Object o : l)
- System.out.println(o);
- }
看看這個方法有沒有異議,這個方法會通過編譯的,假如你傳入String,就是這樣List<String>。
接着我們調用它,問題就出現了,我們將一個List<String>當作List傳給了方法,JVM會給我們一個警告,說這個破壞了類型安全,因爲從List中返回的都是Object類型的,而讓我們再看看下面的方法。
實際上,JVM並不會發出任何警告,也許發出警報,我沒有看到。總而言之,使用Code list 2 當傳入List<String> 的時候,是可以出結果的,完全正確的。
我的測試代碼如下:
- package com.testing;
- import java.util.ArrayList;
- import java.util.List;
- public class Test {
- public static void main(String[] args) {
- List<String> list = new ArrayList<String>();
- list.add("123");
- list.add("456");
- TestMethod(list);
- }
- public static void TestMethod(List l){
- for(Object o:l){
- System.out.println(o);
- }
- }
- }
123
456
- //Code list 3
- void TestGen0Medthod1(List<String> l) {
- for (Object o : l)
- System.out.println(o);
- }
因爲這裏的List<String>不是List<Object>的子類,不是String與Object的關係,就是說List<String>不隸屬於list<Object>,他們不是繼承關係,所以是不行的,這裏的extends是表示限制的。
類型通配符是很神奇的,List<?>這個你能爲他做什麼呢?怎麼都是“?”,它似乎不確定,他總不能返回一個?作爲類型的數據吧,是啊他是不會返回一個“?”來問程序員的?JVM會做簡單的思考的,看看代碼吧,更直觀些。
- //code list 4
- List<String> l1 = new ArrayList<String>();
- li.add(“String”);
- List<?> l2 = l1;
- System.out.println(l1.get(0));
這段代碼沒問題的,l1.get(0)將返回一個Object。
我認爲上句話是不對的,l1.get(0) 將返回一個String,由於List中存放的所有數據均是String類型的,及List<String>。
我的測試代碼如下:
- package com.testing;
- import java.util.ArrayList;
- import java.util.List;
- public class Test {
- public static void main(String[] args) {
- List<String> list = new ArrayList<String>();
- list.add("123");
- list.add("456");
- List<?> list2 = list;
- System.out.println(list2.getClass());
- System.out.println(list.get(0).getClass());
- System.out.println(list2.get(0).getClass());
- }
- }
結果:
class java.util.ArrayList
class java.lang.String
class java.lang.String
當上面的代碼中的List<?> 改爲:List 時候,結果不變。
1) 在定義一個泛型類的時候,在 “<>”之間定義形式類型參數,例如:“class TestGen<K,V>”,其中“K” , “V”不代表值,而是表示類型。
2) 實例化泛型對象的時候,一定要在類名後面指定類型參數的值(類型),一共要有兩次書寫。例如:
TestGen<String,String> t=new TestGen<String,String>();
3) 泛型中<K extends Object>,extends並不代表繼承,它是類型範圍限制。
2、泛型與數據類型轉換
2.1. 消除類型轉換
上面的例子大家看到什麼了,數據類型轉換的代碼不見了。在以前我們經常要書寫以下代碼,如:
- //code list 5
- import Java.util.Hashtable;
- class Test {
- public static void main(String[] args) {
- Hashtable h = new Hashtable();
- h.put("key", "value");
- String s = (String)h.get("key");
- System.out.println(s);
- }
- }
這個我們做了類型轉換,是不是感覺很煩的,並且強制類型轉換會帶來潛在的危險,系統可能會拋一個ClassCastException異常信息。在JDK5.0中我們完全可以這麼做,如:
- //code list 6
- import Java.util.Hashtable;
- class Test {
- public static void main(String[] args) {
- Hashtable<String,Integer> h = new Hashtable<String,Integer> ();
- h.put("key", new Integer(123));
- int s = h.get("key").intValue();
- System.out.println(s);
- }
- }
這裏我們使用泛化版本的HashMap,這樣就不用我們來編寫類型轉換的代碼了,類型轉換的過程交給編譯器來處理,是不是很方便,而且很安全。上面是String映射到String,也可以將Integer映射爲String,只要寫成HashTable<Integer,String> h=new HashTable<Integer,String>();h.get(new Integer(0))返回value。果然很方便。
2.2 自動解包裝與自動包裝的功能
從上面有沒有看到有點彆扭啊,h.get(new Integer(123))這裏的new Integer(123);好煩的,在JDK5.0之前我們只能忍着了,現在這種問題已經解決了,請看下面這個方法。我們傳入一個int這一基本類別,然後再將i的值直接添加到List中,其實List是不能儲存基本型別的,List中應該存儲對象,這裏編譯器將int包裝成Integer,然後添加到List中去。接着我們用List.get(0);來檢索數據,並返回對象再將對象解包裝成int。恩,JDK5.0給我們帶來更多方便與安全。
- <span style="color:#990000;">//Code list 7
- public void autoBoxingUnboxing(int i) {
- ArrayList<Integer> L= new ArrayList<Integer>();
- L.add(i);
- int a = L.get(0);
- System.out.println("The value of i is " + a);
- } </span>
2.3 限制泛型中類型參數的範圍
也許你已經發現在code list 1中的TestGen<K,V>這個泛型類,其中K,V可以是任意的型別。也許你有時候呢想限定一下K和V當然範圍,怎麼做呢?看看如下的代碼:
- //Code list 8
- class TestGen2<K extents String,V extends Number>
- {
- private V v=null;
- private K k=null;
- public void setV(V v){
- this.v=v;
- }
- public V getV(){
- return this.v;
- }
- public void setK(K k){
- this.k=k;
- }
- public V getK(){
- return this.k;
- }
- public static void main(String[] args)
- {
- TestGen2<String,Integer> t2=new TestGen2<String,Integer>();
- t2.setK(new String("String"));
- t2.setV(new Integer(123));
- System.out.println(t2.getK());
- System.out.println(t2.getV());
- }
- }
上邊K的範圍是<=String ,V的範圍是<=Number,注意是“<=”,對於K可以是String的,V當然也可以是Number,也可以是Integer,Float,Double,Byte等。看看下圖也許能直觀些請看上圖A是上圖類中的基類,A1,A2分別是A的子類,A2有2個子類分別是A2_1,A2_2。
然後我們定義一個受限的泛型類class MyGen<E extends A2>,這個泛型的範圍就是上圖中蘭色部分。
這個是單一的限制,你也可以對類別多重限制,如下:
class C<T extends Comparable<? super T> & Serializable>
我們來分析以下這句,T extends Comparable這個是對上限的限制,Comparable< super T>這個是下限的限制,Serializable是第2個上限。一個指定的類型參數可以具有一個或多個上限。具有多重限制的類型參數可以用於訪問它的每個限制的方法和域。
2.4. 多態方法
- //Code list 9
- class TestGen {
- <T extends Object> public static List<T> make(T first) {
- return new List<T>(first);
- }
- }