1.概念

泛型是Java 1.5版本才引進的概念，在這之前是沒有泛型的，但是泛型程式碼能夠很好地和之前版本的程式碼相容。那是因為，泛型資訊只存在於程式碼編譯階段，在進入JVM之前，與泛型相關的資訊會被擦除掉，我們稱之為–型別擦除。

2.分類：

• 無限制型別擦除

程式碼演示：

 1 package com.genericity.demo5;
 2 
 3 public class Earase<T> {
 4     private T key;
 5 
 6     public T getKey() {
 7         return key;
 8     }
 9
 
 
10     public void setKey(T key) {
11         this.key = key;
12     }
13 }

 1 package com.genericity.demo5;
 2 
 3 import org.omg.PortableInterceptor.INACTIVE;
 4 
 5 import java.lang.reflect.Field;
 6 import java.util.ArrayList;
 7 
 8 public class Test2 {
 9     public static void main(String[] args) {
 
10         Earase<Integer> integerEarase=new Earase<>();
11         //利用反射，獲取Earase類的位元組碼檔案的class類物件
12         Class<? extends Earase> aClass = integerEarase.getClass();
13         Field[] declaredFields = aClass.getDeclaredFields();
14         for (Field declaredField : declaredFields) {
 
15             System.out.println(declaredField.getName()+":"+declaredField.getType().getSimpleName());
16         }
17     }
18 }
19 //執行結果：key:Object

• 有限制類型擦除

 1 package com.genericity.demo6;
 2 
 3 public class Earase<T extends  Number> {
 4     private T key;
 5 
 6     public T getKey() {
 7         return key;
 8     }
 9 
10     public void setKey(T key) {
11         this.key = key;
12     }
13 }

 1 package com.genericity.demo6;
 2 
 3 import java.lang.reflect.Field;
 4 
 5 public class Test2 {
 6     public static void main(String[] args) {
 7         Earase<Integer> integerEarase=new Earase<>();
 8         //利用反射，獲取Earase類的位元組碼檔案的class類物件
 9         Class<? extends Earase> aClass = integerEarase.getClass();
10         Field[] declaredFields = aClass.getDeclaredFields();
11         for (Field declaredField : declaredFields) {
12             System.out.println(declaredField.getName()+":"+declaredField.getType().getSimpleName());
13         }
14     }
15 }
16 //執行結果：key:Number

• 擦除方法中型別定義的引數

 1 package com.genericity.demo6;
 2 
 3 import java.util.List;
 4 
 5 public class Earase<T extends  Number> {
 6     private T key;
 7 
 8     public T getKey() {
 9         return key;
10     }
11 
12     public void setKey(T key) {
13         this.key = key;
14     }
15 
16     /**
17      * 泛型方法
18      * @param t 引數也只能是List型別，或者是List型別的子類才行
19      * @param <T>
20      * @return
21      */
22     public <T extends List> T show(T t){
23         return t;
24     }
25 }

1 Method[] declaredMethods = aClass.getDeclaredMethods();//獲取類中的所有方法
2         for (Method declaredMethod : declaredMethods) {
3             System.out.println(declaredMethod.getName()+":"+declaredMethod.getReturnType().getSimpleName());
4         }
5         //執行結果：
6         //getKey:Number
7         //setKey:void
8         //show:List

• 橋接方法

1 package com.genericity.demo6;
2 
3 /**
4  * 泛型介面
5  * @param <T>
6  */
7 public interface Info<T> {
8     T info(T t);
9 }

1 package com.genericity.demo6;
2 
3 public class InfoImpl implements Info<Integer> {
4     @Override
5     public Integer info(Integer value) {
6         return value;
7     }
8 }

 1    InfoImpl info = new InfoImpl();
 2         Class<? extends InfoImpl> aClass1 = info.getClass();
 3         //當然，我們在獲取類的位元組碼檔案的時候，也可以直接使用.class的方式   Class<InfoImpl>  aClass1=InfoImpl.class
 4         Method[] declaredMethods1 = aClass1.getDeclaredMethods();
 5         for (Method method : declaredMethods1) {
 6             System.out.println(method.getName()+":"+method.getReturnType().getSimpleName());
 7         }
 8 
 9         //執行結果：
10         //info:Integer
11         //info:Object