1. 先解釋下泛型概念

泛型是Java SE 1.5的新特性，泛型的本質(zhì)是參數(shù)化類型映穗，也就是說所操作的數(shù)據(jù)類型被指定為一個(gè)參數(shù)窖张。這種參數(shù)類型可以用在類、接口和方法的創(chuàng)建中男公，分別稱為泛型類荤堪、泛型接口、泛型方法枢赔。Java語言引入泛型的好處是安全簡(jiǎn)單澄阳。
在Java SE 1.5之前，沒有泛型的情況的下踏拜，通過對(duì)類型Object的引用來實(shí)現(xiàn)參數(shù)的“任意化”碎赢，“任意化”帶來的缺點(diǎn)是要做顯式的強(qiáng)制類型轉(zhuǎn)換，而這種轉(zhuǎn)換是要求開發(fā)者對(duì)實(shí)際參數(shù)類型可以預(yù)知的情況下進(jìn)行的速梗。對(duì)于強(qiáng)制類型轉(zhuǎn)換錯(cuò)誤的情況肮塞，編譯器可能不提示錯(cuò)誤襟齿，在運(yùn)行的時(shí)候才出現(xiàn)異常，這是一個(gè)安全隱患枕赵。
泛型的好處是在編譯的時(shí)候檢查類型安全猜欺，并且所有的強(qiáng)制轉(zhuǎn)換都是自動(dòng)和隱式的，以提高代碼的重用率拷窜。

以上內(nèi)容摘自百度百科

舉個(gè)栗子:
Box類定義為一個(gè)泛型類

public class Box<T> {
    private T object;

    public void set(T object) { this.object = object; }
    public T get() { return object; }
}

創(chuàng)建一個(gè)Box對(duì)象开皿，不帶泛型參數(shù)，發(fā)現(xiàn)獲取對(duì)象的時(shí)候需要強(qiáng)制轉(zhuǎn)換

Box box2 = new Box();
box2.set(new Apple());
Apple apple = (Apple) box2.get();

創(chuàng)建一個(gè)Box對(duì)象篮昧，帶泛型參數(shù)赋荆，獲取對(duì)象的時(shí)候就不需要強(qiáng)制轉(zhuǎn)換

Box<Apple> box = new Box<Apple>();
box.set(new Apple());
Apple apple = box.get();

總結(jié)下泛型的好處就是
省去了強(qiáng)制轉(zhuǎn)換，可以在編譯時(shí)候檢查類型安全懊昨，可以用在類窄潭，方法，接口上

但是我們定義泛型類酵颁，泛型方法嫉你，泛型接口的時(shí)候經(jīng)常會(huì)碰見很多不同的通配符T，E材义，K均抽，V等等嫁赏，這些通配符又都是什么意思呢其掂？繼續(xù)往下看

2. 下來說說泛型通配符T，E潦蝇，K款熬，V區(qū)別

這些全都屬于java泛型的通配符，剛開始我看到這么多通配符攘乒，一下暈了贤牛，這幾個(gè)其實(shí)沒什么區(qū)別，只不過是一個(gè)約定好的代碼则酝，也就是說

使用大寫字母A,B,C,D......X,Y,Z定義的殉簸，就都是泛型，把T換成A也一樣沽讹，這里T只是名字上的意義而已

• 般卑？ 表示不確定的java類型
• T (type) 表示具體的一個(gè)java類型
• K V (key value) 分別代表java鍵值中的Key Value
• E (element) 代表Element

舉個(gè)栗子：

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，在執(zhí)行效果上是沒有任何區(qū)別的爽雄，只不過我們約定好了T代表type蝠检，所以還是按照約定規(guī)范來比較好，增加了代碼的可讀性挚瘟。

如果要定義多個(gè)泛型參數(shù)叹谁，比如說兩個(gè)泛型參數(shù)
很典型的一個(gè)栗子是Map的key,value泛型饲梭，我們也可以定義一個(gè)這樣的

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; }
}

下來就可以傳入任意類型，創(chuàng)建實(shí)例了焰檩，不用轉(zhuǎn)化類型

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);

如果要定義超過兩個(gè)憔涉，三個(gè)或三個(gè)以上的泛型參數(shù)可以使用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<?>區(qū)別

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不同點(diǎn)在于顿乒，Object是一個(gè)實(shí)打?qū)嵉念?并沒有泛指誰议街，而T可以泛指Object，比方public void printList(List<T> list){}方法中可以傳入List<Object> list類型參數(shù)璧榄，也可以傳入List<String> list類型參數(shù)特漩，但是public void printList(List<Object> list){}就只可以傳入List<Object> list類型參數(shù)，因?yàn)镺bject類型并沒有泛指誰骨杂，是一個(gè)確定的類型
• ?和T區(qū)別是涂身？是一個(gè)不確定類，搓蚪？和T都表示不確定的類型 蛤售，但如果是T的話，函數(shù)里面可以對(duì)T進(jìn)行操作妒潭，比方 T car = getCar()悴能，而不能用？ car = getCar()雳灾。

下面舉個(gè)栗子比較下這三種：

package com.lyang.demo.fanxing;

import java.util.Arrays;
import java.util.List;

/**
 * 測(cè)試泛型參數(shù)Object和T的區(qū)別
 * 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());
        /*
        * 下面這句會(huì)編譯報(bào)錯(cuò)漠酿，因?yàn)閰?shù)不能轉(zhuǎn)化成功
        * */
        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<?>區(qū)別

T是一種具體的類炒嘲，例如String,List,Map......等等，這些都是屬于具體的類匈庭，這個(gè)比較好理解
** Class是什么呢夫凸，Class也是一個(gè)類，但Class是存放上面String,List,Map......類信息的一個(gè)類**嚎花，有點(diǎn)抽象寸痢，我們一步一步來看 。

如何獲取到Class類呢紊选，有三種方式：
1. 調(diào)用Object類的getClass()方法來得到Class對(duì)象啼止，這也是最常見的產(chǎn)生Class對(duì)象的方法道逗。
例如：

List list = null;
Class clazz = list.getClass();

**2. 使用Class類的中靜態(tài)forName()方法獲得與字符串對(duì)應(yīng)的Class對(duì)象。
**
例如：

Class clazz = Class.forName("com.lyang.demo.fanxing.People");

3.獲取Class類型對(duì)象的第三個(gè)方法非常簡(jiǎn)單献烦。如果T是一個(gè)Java類型滓窍，那么T.class就代表了匹配的類對(duì)象。

Class clazz = List.class;

** 那么問題來了巩那？Class類是創(chuàng)建出來了吏夯，但是Class<T>和Class<?>適用于什么時(shí)候呢？即横？噪生？**

使用Class<T>和Class<?>多發(fā)生在反射場(chǎng)景下，先看看如果我們不使用泛型东囚，反射創(chuàng)建一個(gè)類是什么樣的跺嗽。

People people = (People) Class.forName("com.lyang.demo.fanxing.People").newInstance();

看到了么，需要強(qiáng)轉(zhuǎn)页藻，如果反射的類型不是People類桨嫁，就會(huì)報(bào)
java.lang.ClassCastException錯(cuò)誤。

使用Class<T>泛型后份帐，不用強(qiáng)轉(zhuǎn)了

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<?>有什么區(qū)別呢璃吧？
Class<T>在實(shí)例化的時(shí)候，T要替換成具體類
Class<?>它是個(gè)通配泛型废境，?可以代表任何類型畜挨，主要用于聲明時(shí)的限制情況
例如可以聲明一個(gè)

public Class<?> clazz;

但是你不能聲明一個(gè)

public Class<T> clazz;

因?yàn)門需要指定類型
所以當(dāng)，不知道定聲明什么類型的Class的時(shí)候可以定義一個(gè)Class<?>,Class<?>可以用于參數(shù)類型定義彬坏，方法返回值定義等朦促。

以上所有示例的代碼我已經(jīng)提交到了github，有興趣的同學(xué)可以去看看https://github.com/qwertyanglu/FanxingDemo

個(gè)人的一些理解栓始，如果有不對(duì)的地方，歡迎各位前輩給出寶貴指導(dǎo)血当，在此先行謝過幻赚。