JAVA總結--泛型
泛型 ：程序設計語言的一種特性；將類型參數化；
特征：凡是涉及到強制類型轉化的地方，使用泛型均會編譯出現問題；泛型僅僅在編譯時進行校驗，使用泛型的對象，其本質的類型依然不變；
ps：不存在泛型數組
一、出現泛型的原因
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 List list = new ArrayList(); 5 list.add("qqyumidi"); 6 list.add("corn");7 list.add(100); 8 9 for (int i = 0; i < list.size(); i++) { 10 String name = (String) list.get(i); // 1 11 System.out.println("name:" + name); 12 } 13 } 14 }
位置//1編譯階段正常，而運行時會出現“java.lang.ClassCastException”異常
在如上的編碼過程中，我們發現主要存在兩個問題：
1.當我們將一個對象放入集合中，集合不會記住此對象的類型，當再次從集合中取出此對象時，改對象的編譯類型變成了Object類型，但其運行時類型任然為其本身類型。
2.因此，位置//1處取出集合元素時需要人為的強制類型轉化到具體的目標類型，且很容易出現“java.lang.ClassCastException”異常。
那麽有沒有什麽辦法可以使集合能夠記住集合內元素各類型，且能夠達到只要編譯時不出現問題，運行時就不會出現“java.lang.ClassCastException”異常呢？答案就是使用泛型。
二、泛型引入
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 5 List<String> list = newArrayList<String>(); 6 list.add("qqyumidi"); 7 list.add("corn"); 8 //list.add(100); // 1 提示編譯錯誤 9 10 for (int i = 0; i < list.size(); i++) { 11 String name = list.get(i); // 2 12 System.out.println("name:" + name); 13 } 14 } 15 }
采用泛型寫法後，在//1處想加入一個Integer類型的對象時會出現編譯錯誤，通過List<String>，直接限定了list集合中只能含有String類型的元素，
從而在//2處無須進行強制類型轉換，因為此時，集合能夠記住元素的類型信息，編譯器已經能夠確認它是String類型了。
結合上面的泛型定義，我們知道在List<String>中，String是類型實參，也就是說，相應的List接口中肯定含有類型形參。
且get()方法的返回結果也直接是此形參類型（也就是對應的傳入的類型實參）。
下面就來看看List接口的的具體定義：
1 public interface List<E> extends Collection<E> { 2 3 int size(); 4 5 boolean isEmpty(); 6 7 boolean contains(Object o); 8 9 Iterator<E> iterator(); 10 11 Object[] toArray(); 12 13 <T> T[] toArray(T[] a); 14 15 boolean add(E e); 16 17 boolean remove(Object o); 18 19 boolean containsAll(Collection<?> c); 20 21 boolean addAll(Collection<? extends E> c); 22 23 boolean addAll(int index, Collection<? extends E> c); 24 25 boolean removeAll(Collection<?> c); 26 27 boolean retainAll(Collection<?> c); 28 29 void clear(); 30 31 boolean equals(Object o); 32 33 int hashCode(); 34 35 E get(int index); 36 37 E set(int index, E element); 38 39 void add(int index, E element); 40 41 E remove(int index); 42 43 int indexOf(Object o); 44 45 int lastIndexOf(Object o); 46 47 ListIterator<E> listIterator(); 48 49 ListIterator<E> listIterator(int index); 50 51 List<E> subList(int fromIndex, int toIndex); 52 }
1 public class ArrayList<E> extends AbstractList<E> 2 implements List<E>, RandomAccess, Cloneable, java.io.Serializable { 3 4 public boolean add(E e) { 5 ensureCapacityInternal(size + 1); // Increments modCount!! 6 elementData[size++] = e; 7 return true; 8 } 9 10 public E get(int index) { 11 rangeCheck(index); 12 checkForComodification(); 13 return ArrayList.this.elementData(offset + index); 14 } 15 16 //...省略掉其他具體的定義過程 17 18 }
在List接口中采用泛型化定義之後，<E>中的E表示類型形參，可以接收具體的類型實參，並且此接口定義中，凡是出現E的地方均表示相同的接受自外部的類型實參。
三.自定義泛型接口、泛型類和泛型方法
泛型可以分為泛型接口、泛型類和泛型方法；
1、泛型類與泛型方法例子：
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 5 Box<String> name = new Box<String>("corn"); 6 System.out.println("name:" + name.getData()); 7 } 8 9 } 10 11 class Box<T> { 12 13 private T data; 14 15 public Box() { 16 17 } 18 19 public Box(T data) { 20 this.data = data; 21 } 22 23 public T getData() { 24 return data; 25 } 26 27 }
在泛型接口、泛型類和泛型方法的定義過程中，我們常見的如T、E、K、V等形式的參數常用於表示泛型形參，由於接收來自外部使用時候傳入的類型實參。
2、傳入不同類型，其對象實例的類型未發生變化
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 5 Box<String> name = new Box<String>("corn"); 6 Box<Integer> age = new Box<Integer>(712); 7 8 System.out.println("name class:" + name.getClass()); // com.qqyumidi.Box 9 System.out.println("age class:" + age.getClass()); // com.qqyumidi.Box 10 System.out.println(name.getClass() == age.getClass()); // true 11 12 } 13 14 }
在使用泛型類時，雖然傳入了不同的泛型實參，但並沒有真正意義上生成不同的類型，我們僅僅在邏輯上可以理解成多個不同的泛型類型；
在編譯過程中，對於正確檢驗泛型結果後，會將泛型的相關信息擦出，也就是說，成功編譯過後的class文件中是不包含任何泛型信息的。泛型信息不會進入到運行時階段。
即，泛型類型在邏輯上看以看成是多個不同的類型，實際上都是相同的基本類型；
四、通配符的出現
1、Box<Number>和Box<Integer>實際上都是Box類型，但是，相互之間並不是父子關系；
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 5 Box<Number> name = new Box<Number>(99); 6 Box<Integer> age = new Box<Integer>(712); 7 8 getData(name); 9 10 //The method getData(Box<Number>) in the type GenericTest is 11 //not applicable for the arguments (Box<Integer>) 12 getData(age); // 1 13 14 } 15 16 public static void getData(Box<Number> data){ 17 System.out.println("data :" + data.getData()); 18 } 19 20 }
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 5 Box<Integer> a = new Box<Integer>(712); 6 Box<Number> b = a; // 1 7 Box<Float> f = new Box<Float>(3.14f); 8 b.setData(f); // 2 9 10 } 11 12 public static void getData(Box<Number> data) { 13 System.out.println("data :" + data.getData()); 14 } 15 16 }
顯然//1和//2處肯定會出現錯誤提示的。
假設Box<Number>在邏輯上可以視為Box<Integer>的父類，那麽//1和//2處將不會有錯誤提示了，那麽問題就出來了，通過getData()方法取出數據時到底是什麽類型呢？Integer? Float? 還是Number？
且由於在編程過程中的順序不可控性，導致在必要的時候必須要進行類型判斷，且進行強制類型轉換。
這種問題的解決方式就是類型通配符
2、類型通配符
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 5 Box<String> name = new Box<String>("corn"); 6 Box<Integer> age = new Box<Integer>(712); 7 Box<Number> number = new Box<Number>(314); 8 9 getData(name); 10 getData(age); 11 getData(number); 12 } 13 14 public static void getData(Box<?> data) { 15 System.out.println("data :" + data.getData()); 16 } 17 18 }
1 public class GenericTest { 2 3 public static void main(String[] args) { 4 5 Box<String> name = new Box<String>("corn"); 6 Box<Integer> age = new Box<Integer>(712); 7 Box<Number> number = new Box<Number>(314); 8 9 getData(name); 10 getData(age); 11 getData(number); 12 13 //getUpperNumberData(name); // 1 14 getUpperNumberData(age); // 2 15 getUpperNumberData(number); // 3 16 } 17 18 public static void getData(Box<?> data) { 19 System.out.println("data :" + data.getData()); 20 } 21 22 public static void getUpperNumberData(Box<? extends Number> data){ 23 System.out.println("data :" + data.getData()); 24 } 25 26 }
在代碼//1處調用將出現錯誤提示，而//2 //3處調用正常。
類型通配符上限通過形如Box<? extends Number>形式定義，相對應的，類型通配符下限為Box<? super Number>形式，其含義與類型通配符上限正好相反；
JAVA總結--泛型