JAVA泛型通配符T，E，K，V區別，T以及Class<T>，Class<?>的區別
1. 先解釋下泛型概念
泛型是Java SE 1.5的新特性，泛型的本質是參數化類型，也就是說所操作的數據類型被指定爲一個參數。這種參數類型可以用在類、接口和方法的創建中，分別稱爲泛型類、泛型接口、泛型方法。Java語言引入泛型的好處是安全簡單。
在Java SE 1.5之前，沒有泛型的情況的下，通過對類型Object的引用來實現參數的“任意化”，“任意化”帶來的缺點是要做顯式的強制類型轉換，而這種轉換是要求開發者對實際參數類型可以預知的情況下進行的。對於強制類型轉換錯誤的情況，編譯器可能不提示錯誤，在運行的時候纔出現異常，這是一個安全隱患。
泛型的好處是在編譯的時候檢查類型安全，並且所有的強制轉換都是自動和隱式的，以提高代碼的重用率。
以上內容摘自百度百科
舉個栗子:
Box類定義爲一個泛型類
public class Box<T> {
private T object;
public void set(T object) { this.object = object; }
public T get() { return object; }
}
創建一個Box對象，不帶泛型參數，發現獲取對象的時候需要強制轉換
Box box2 = new Box();
box2.set(new Apple());
Apple apple = (Apple) box2.get();
創建一個Box對象，帶泛型參數，獲取對象的時候就不需要強制轉換
Box<Apple> box = new Box<Apple>();
box.set(new Apple());
Apple apple = box.get();
總結下泛型的好處就是
省去了強制轉換，可以在編譯時候檢查類型安全，可以用在類，方法，接口上
但是我們定義泛型類，泛型方法，泛型接口的時候經常會碰見很多不同的通配符T，E，K，V等等，這些通配符又都是什麼意思呢？繼續往下看
2. 下來說說泛型通配符T，E，K，V區別
這些全都屬於java泛型的通配符，剛開始我看到這麼多通配符，一下暈了，這幾個其實沒什麼區別，只不過是一個約定好的代碼，也就是說
使用大寫字母A,B,C,D......X,Y,Z定義的，就都是泛型，把T換成A也一樣，這裏T只是名字上的意義而已
- ？ 表示不確定的java類型
- T (type) 表示具體的一個java類型
- K V (key value) 分別代表java鍵值中的Key Value
- E (element) 代表Element
舉個栗子：
public class Test<T> {
public List<T> list = new ArrayList<T>();
public static void main(String[] args) {
Test<String> test = new Test<String>();
test.list.add("hello");
System.out.println(test.list);
}}
和
public class Test<A> {
public List<A> list = new ArrayList<A>();
public static void main(String[] args) {
Test<String> test = new Test<String>();
test.list.add("hello");
System.out.println(test.list);
}}
將T換成了A，在執行效果上是沒有任何區別的，只不過我們約定好了T代表type，所以還是按照約定規範來比較好，增加了代碼的可讀性。
如果要定義多個泛型參數，比如說兩個泛型參數
很典型的一個栗子是Map的key,value泛型，我們也可以定義一個這樣的
public interface Mymap<K, V> {
public K getKey();
public V getValue();
}
public class MymapImpl<K, V> implements Mymap<K, V> {
private K key;
private V value;
public MymapImpl(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() { return key; }
public V getValue() { return value; }
}
下來就可以傳入任意類型，創建實例了，不用轉化類型
Mymap<String, Integer> mp1= new MymapImpl<String, Integer>("Even", 8);
Mymap<String, String> mp2= new MymapImpl<String, String>("hello", "world");
Mymap<Integer, Integer> mp3= new MymapImpl<Integer, Integer>(888, 888);
如果要定義超過兩個，三個或三個以上的泛型參數可以使用T1, T2, ..., Tn，像這樣子
public class Test<T1,T2,T3> {
public void print(T1 t1,T2 t2,T3 t3){
System.out.println(t1.getClass());
System.out.println(t2.getClass());
System.out.println(t3.getClass());
}
}
3. 接下來說說List<T>，List<Object>，List<?>區別
ArrayList<T> al=new ArrayList<T>(); 指定集合元素只能是T類型
ArrayList<?> al=new ArrayList<?>(); 集合元素可以是任意類型，這種沒有意義，一般是方法中，只是爲了說明用法
ArrayList<? extends E> al=new ArrayList<? extends E>();
泛型的限定：
? extends E:接收E類型或者E的子類型。
? super E:接收E類型或者E的父類型
- Object和T不同點在於，Object是一個實打實的類,並沒有泛指誰，而T可以泛指Object，比方public void printList(List<T> list){}方法中可以傳入List<Object> list類型參數，也可以傳入List<String> list類型參數，但是public void printList(List<Object> list){}就只可以傳入List<Object> list類型參數，因爲Object類型並沒有泛指誰，是一個確定的類型
- ?和T區別是？是一個不確定類，？和T都表示不確定的類型 ，但如果是T的話，函數裏面可以對T進行操作，比方 T car = getCar()，而不能用？ car = getCar()。
下面舉個栗子比較下這三種：
package com.lyang.demo.fanxing;
import java.util.Arrays;
import java.util.List;
/**
* 測試泛型參數Object和T的區別
* Created by yanglu on 2017/04/20.
*/
public class TestDifferenceBetweenObjectAndT {
public static void printList1(List<Object> list) {
for (Object elem : list)
System.out.println(elem + " ");
System.out.println();
}
public static <T> void printList2(List<T> list) {
for (T elem : list)
System.out.println(elem + " ");
System.out.println();
}
public static void printList3(List<?> list) {
for (int i = 0;i<list.size();i++)
System.out.println(list.get(i) + " ");
System.out.println();
}
public static void main(String[] args) {
List<Integer> test1 = Arrays.asList(1, 2, 3);
List<String> test2 = Arrays.asList("one", "two", "three");
List<Object> test3 = Arrays.asList(1, "two", 1.23);
List<Fruit> test4 = Arrays.asList(new Apple(), new Banana());
/*
* 下面這句會編譯報錯，因爲參數不能轉化成功
* */
printList1(test4);
/**/
printList1(test3);
printList1(test3);
printList2(test1);
printList2(test2);
printList2(test3);
printList3(test1);
printList3(test2);
printList3(test3);
}
}
image.png
4. 最後來說說T，Class<T>，Class<?>區別
T是一種具體的類，例如String,List,Map......等等，這些都是屬於具體的類，這個比較好理解
** Class是什麼呢，Class也是一個類，但Class是存放上面String,List,Map......類信息的一個類**，有點抽象，我們一步一步來看 。
如何獲取到Class類呢，有三種方式：
1. 調用Object類的getClass()方法來得到Class對象，這也是最常見的產生Class對象的方法。
例如：
List list = null;
Class clazz = list.getClass();
**2. 使用Class類的中靜態forName()方法獲得與字符串對應的Class對象。
**
例如：
Class clazz = Class.forName("com.lyang.demo.fanxing.People");
3.獲取Class類型對象的第三個方法非常簡單。如果T是一個Java類型，那麼T.class就代表了匹配的類對象。
Class clazz = List.class;
** 那麼問題來了？Class類是創建出來了，但是Class<T>和Class<?>適用於什麼時候呢？？？**
使用Class<T>和Class<?>多發生在反射場景下，先看看如果我們不使用泛型，反射創建一個類是什麼樣的。
People people = (People) Class.forName("com.lyang.demo.fanxing.People").newInstance();
看到了麼，需要強轉，如果反射的類型不是People類，就會報
java.lang.ClassCastException錯誤。
使用Class<T>泛型後，不用強轉了
public class Test {
public static <T> T createInstance(Class<T> clazz) throws IllegalAccessException, InstantiationException {
return clazz.newInstance();
}
public static void main(String[] args) throws IllegalAccessException, InstantiationException {
Fruit fruit= createInstance(Fruit .class);
People people= createInstance(People.class);
}
}
那Class<T>和Class<?>有什麼區別呢？
Class<T>在實例化的時候，T要替換成具體類
Class<?>它是個通配泛型，?可以代表任何類型，主要用於聲明時的限制情況
例如可以聲明一個
public Class<?> clazz;
但是你不能聲明一個
public Class<T> clazz;
因爲T需要指定類型
所以當，不知道定聲明什麼類型的Class的時候可以定義一個Class<?>,Class<?>可以用於參數類型定義，方法返回值定義等。