Java泛型的类型擦除

泛型是什么？

泛型的英文是 generics，generic 的意思是通用,而翻译成中文，泛应该意为广泛，型即是类型。所以泛型就是能广泛适用的类型。

但泛型还有一种较为准确的说法就是为了参数化类型，或者说可以将类型当作参数传递给一个类或者是方法。

那么，如何解释类型参数化呢？

public class Test {
   Object value;
   public Object getValue() {
       return value;
   }
   public void setValue(Object value) {
       this.value = value;
   }
}

上面的Object为java.lang包中的所有类的根类，于是，我们可以这样使用它。

Test test = new Test ();
test.setValue('x');//Character包装类的自动装箱
String value1 = (String) test.getValue();
test.setValue(19950904);//Integer包装类自动装箱
int value = (int) test.getValue();

Java八种基本数据类型对应的包装类，以下以int和char型数据对应的包装类为例：

Character ch = new Character('x');//等价于test.setValue('x');
test.setValue(ch )
Integer in = new Integer("19950904");//等价于test.setValue(19950904);
test.setValue(in )

上述方法简单粗暴，只要我们做一个正确的类型强制转换就OK了
但是通过在JDK1.5版本引入泛型之后，它给我们带来了完全不一样的编程体验

public class Test<T> {
   T value;
   public Object getValue() {
       return value;
   }
   public void setValue(T value) {
       this.value = value;
   }
}

这就是泛型，它将Test类的成员变量value这个属性的类型也参数化了，这就是所谓的参数化类型。以下是它的使用方法。

Test<Character> test1 = new Test<Character>();
test1 .setValue('x');
char value1 = test1 .getValue();
Test<Integer> test2 = new Test<Integer>();
test2.setValue(19950904);
int value2 = test2 .getValue();

上述代码最显而易见的好处就是不用再对取出来的结果进行强制的类型转换了。除此之外，还有另外一个特点，那就是，泛型除了可以将参数类型化外，当参数一旦确定好，如果参数类型不匹配，编译器在编译的时候就会因为参数类型不匹配而报错不通过，如下代码在校验泛型指定数据类型是否匹配时就会报错：

Test<String> test1 = new Test<String>();
test1.setValue('liupeng');
String value1 = test1 .getValue();
test1.setValue(19950904);//泛型指定类型不匹配导致报错

因此，综合上述信息，我们可以得出以下结论。
1、与通过Object根类来代替一切类型这样简单粗暴的方式而言，泛型的引入使得数据的类别可以像参数一样由外部传递进来。它提供了一种扩展能力。它更符合面向抽象的编程思想。
2、当具体的类型确定后，泛型又提供了一种类型检测的机制，只有相匹配的数据才能正常的赋值，否则编译器就不通过。所以说，它是一种类型安全检测机制，一定程度上提高了软件的安全性。
3、泛型提高了程序代码的可读性，不必要等到运行的时候才去进行数据类型的强制转换，在定义或者实例化阶段，因为泛型类型显示话的效果，程序员能够一目了然猜测出代码要操作的数据类型。

接下来我们介绍下泛型的相关知识
泛型的分类，按照使用情况可以分为三类：泛型类、泛型方法和泛型接口
1、泛型类
泛型类的定义如下：

public class Test<T> {
   private T field1;
}

尖括号 <> 中的 T 被称作是类型参数，用于指代任何类型。事实上，T只是一种习惯性写法，如果你愿意。你可以写成任意的字符串，如下：

public class Test<LiuPeng> {
   private LiuPeng Field1;
}

但出于规范的目的，Java还是建议我们用单个大写字母来代表类型参数。常见的如：
(1) T 代表一般的任何类。
(2) E 代表 Element 的意思，或者 Exception 异常的意思。
(3) K 代表 Key 的意思。
(4) V 代表 Value 的意思，通常与 K 一起配合使用。
(5) S 代表 Subtype 的意思，文章后面部分会讲解示意。
以下是泛型类的使用：

Test<String> test1 = new Test<>();//泛型指定具体的显示化数据类型为String
Test<Integer> test2 = new Test<>();//泛型指定具体的显示化数据类型为Integer

注意：泛型指定的具体数据类型不能为基本数据类型，必须为其对应的包装类
在对泛型类创建实例对象的时候，只需要在尖括号中赋上具体的数据类型（可以是任何类）即可，T就会被替换成对应的类型，如String 或者是 Integer，泛型类被创建具体实例对象的时候，内部自动扩展成以下代码：

public class Test<String> 
   String field1;               
}

当然，泛型类也可以同时接受多个类型参数，如下定义所示：

public class MultiType <E,T>{
   E filed1;
   T filed2;
   public E getFiled1(){
       return filed1;
   }
   public T getFiled2(){
       return filed2;
   }
}

2、泛型方法
泛型方法的定义如下：

public class Test {
   public <T> void testMethod(T t){
   }
}

泛型方法与泛型类稍有不同的地方是，类型参数也就是尖括号那一部分是写在返回值前面的。<T> 中的 T 被称为类型参数，而方法中参数中的 T 被称为参数化类型，它不是运行时真正的参数。
当然，声明的类型参数，其实也是可以当作返回值的类型的。

public  <T> T testMethod(T t){
       return null;
}

泛型类与泛型方法是可以同时出现在一个类中的，如下所示：

public class Test<T>{
   public  void testMethod1(T t){
       System.out.println(t.getClass().getName());//取的是类的全路径名称
   }
   public  <T> T testMethod2(T t){
       return t;
   }
}

上面代码中，Test<T> 是泛型类，testMethod1 是泛型类中的普通方法，而 testMethod2 是一个泛型方法。而泛型类中的类型参数与泛型方法中的类型参数是没有相应的联系的，泛型方法始终以自己定义的类型参数为准。
针对上面的代码，我们可以这样编写测试代码。

Test<String> t = new Test();
t.testMethod1("liupeng");
Integer i = t.testMethod2(new Integer(19950904));

泛型类的实际类型参数是 String，而传递给泛型方法的类型参数是 Integer，两者互不相干。
但是，为了避免混淆，如果在一个泛型类中存在泛型方法，那么两者的类型参数最好不要同名。比如，Test<T> 代码最好写成以下形式：

public class Test<T>{
   public  void testMethod1(T t){
       System.out.println(t.getClass().getName());//取的是类的全路径名称
   }
   public  <E> E testMethod2(E e){
       return e;
   }
}

3、泛型接口
泛型接口的定义如下：

public interface Interable<T> {
}

泛型接口与泛型类相似，可以在泛型接口中声明相应的泛型方法：

public interface Interable<T>{
   public void testMethod1(T t)；
   public <E> E testMethod2(E e)；
}

通配符 ？
除了用<T>表示泛型外，还有<?>这种形式。？被称为通配符。

class Father{}
class Son extends Father{}
Son son = new Son ();
Father father = son;

如上代码显示，Father是Son的父类，它们之间是继承关系，所以Son的实例可以给一个 Father引用赋值，那么以下代码会编译通过吗？

List<Son> sonList = new ArrayList<>();
List<Father> fatherList = sonList ;

答案是肯定不行的。
编译器不会让它通过的。Son是Father的子类，不代表 List<Son> 和 List<Father> 有继承关系。
但是，现实的编码中，确实存在此类需求，希望泛型能够处理某一范围内的数据类型，比如某个类和它的子类，对此 Java 引入了通配符这个概念。
所以，通配符的出现是为了指定泛型中的类型范围。
通配符有 下一三种形式。
1、 <?> 被称作无限定的通配符。
无限定通配符

public void testMethod(Collection<?> collection){
}

上面的代码中，方法内的参数是被无限定通配符修饰的 Collection 对象，它隐略地表达了一个意图或者可以说是限定，那就是 testMethod() 这个方法内部无需关注 Collection 中的真实类型，因为它是未知的。所以，你只能调用 Collection 中与类型无关的方法。

pubilc class Tset{
   public void testMethod(Collection<?> collection){
      collection.add(1995);//编译出错，无法确认真实数据类型
      collection.add("liupeng");//编译出错，无法确认真实数据类型
      collection.add(new Object());//编译出错，无法确认真实数据类型-正常
      collection.iterator().next();//迭代器遍历,与数据类型无关
      collection.size();//容器容量,与数据类型无关-正常
   }
}

有人说，<?> 提供了只读的功能，也就是它删减了增加具体类型元素的能力，只保留与具体类型无关的功能。它不管装载在这个容器内的元素是什么类型，它只关心元素的数量、容器是否为空等。
2、 <? extends T> 被称作有上限的通配符。
<?> 代表着类型未知，但是我们的确需要对于类型的描述再精确一点，我们希望在一个范围内确定类别，比如类型 A 及 类型 A 的子类都可以。
那么我们就可以采用如下的定义方式：

public void test(Collection<? extends Father> param){
}

上面代码中，para 这个 Collection 接受 Father及 Father的子类的类型。
但是，它仍然丧失了写操作的能力。也就是说以下代码仍然编译不通过。

param.add(new Son());
param.add(new Father());

没有关系，我们不知道具体类型，但是我们至少清楚了类型的范围。
3、 <? super T> 被称作有下限的通配符。
这个和 <? extends T> 相对应，代表 T 及 T 的超类。

public void test(Collection<? super Son> param){
}

<? super T> 神奇的地方在于，它拥有一定程度的写操作的能力。

public void test(Collection<? super Son> param){
   param.add(new Son());//编译通过
   param.add(new Father());//编译不通过
}

<类型擦除>
泛型是Java 1.5版本才引进的概念，在这之前是没有泛型的概念的，但显然，泛型代码能够很好地和之前版本的代码很好地兼容。
这是因为，泛型信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除。
通俗地讲，泛型类和普通类在java虚拟机内是没有什么特别的地方。

List<String> list1 = new ArrayList<String>();
List<Integer> list2 = new ArrayList<Integer>();
System.out.println(list1.getClass() == list.getClass());

输出的结果为true是因为List<String>和 List<Integer>在jvm中的Class都是 List.class。泛型信息被擦除了。
有人可能会问，那类型String和Integer怎么办？答案是泛型转译。

public class Test<T>{
   T object;
   public Test(T object) {//通过构造方法给成员变量object传递值
       this.object = object;
   }
}

Test是一个泛型类，我们查看它在运行时的状态信息可以通过Java反射机制。

Test<String> test = new Test<String>("liupeng");
System.out.println("test class is:" + test.getClass().getName());

输出的结果是：

test class is:com.hundsun.lp.Test

Class 的类型仍然是Test并不是Test<T>这种形式，那我们再看看泛型类中T的类型在 jvm 中是什么具体类型。

Field[] fd = test.getClass().getDeclaredFields();
for (Field f:fd) {
   System.out.println("Field name "+f.getName()+" type:"+f.getType().getName());
}

输出结果是

Field name object type:java.lang.Object

我们更改下上述代码，再看下测试结果

public class Test<T extends String>{
//  public class Test<T>{
   T object;
   public Erasure(T object) {
       this.object = object;
   }
}

输出结果是

Field name object type:java.lang.String

综上所述，我们可以得出以下结论：
在泛型类被类型擦除的时候，之前泛型类中的类型参数部分如果没有指定上限，如<T>则会被转译成普通的Object 类型，如果指定了上限如<T extends String>则类型参数就被替换成类型上限。
所以，在反射中。

public class Test<T>{
   T object;
   public Test(T object) {
       this.object = object;
   }
   public void add(T object){
   }
}

add() 这个方法对应的Method的签名应该是 Object.class。
实际结果如下：

Test <String> test = new Test <String>("hello");
System.out.println("erasure class is:"+ test.getClass().getName());
Method[] methods =  test.getClass().getDeclaredMethods();
for ( Method m:methods ){
   System.out.println(" method:"+m.toString());
}

输出结果是：

method:public void com.hundsun.lp.Test.add(java.lang.Object)

也就是说，如果你要在反射中找到add对应的 Method，你应该调用 getDeclaredMethod("add",Object.class) 否则程序会报错，提示没有这么一个方法，原因就是类型擦除的时候，T被替换成Object 类型了。

类型擦除带来的局限性
类型擦除，是泛型能够与之前的java版本代码兼容共存的原因。但也因为类型擦除，它会抹掉很多继承相关的特性，这是它带来的局限性。

public class Test{
    public static void mian(){
      List<Integer> list1 = new ArrayList<>();
      list1.add(19950904);//正常
      list1.add("liupeng");//类型不匹配导致报错
    }
}

正常情况下，因为泛型的限制，编译器不让最后一行代码编译通过，因为类似不匹配，但是，基于对类型擦除的了解，利用反射，我们可以绕过这个限制。

对泛型方法的困惑

public <T> T test(T t){
   return null;
}

有的同学可能对于连续的两个T感到困惑，其实<T>是为了说明类型参数，是声明,而后面的不带尖括号的T是方法的返回值类型。
你可以相像一下，如果test()这样被调用

test("liupeng");

那么实际相当于

public String test(String t);

Java 不能创建具体类型的泛型数组，因为类型擦除，程序无法分辨一个数组中的元素类型具体是什么类型。

List<Integer>[] li2 = new ArrayList<Integer>[];//List<Integer>在 jvm 中等同于List<Object>
List<Boolean> li3 = new ArrayList<Boolean>[];//List<Boolean>在 jvm 中等同于List<Object>

但是，

List<?>[] li3 = new ArrayList<?>[10];
li3[1] = new ArrayList<String>();
List<?> v = li3[1];

借助于无限定通配符却可以，前面讲过 ？ 代表未知类型，所以它涉及的操作都基本上与类型无关，因此 jvm 不需要针对它对类型作判断，因此它能编译通过，但是，只提供了数组中的元素，因为通配符原因，它只能读，不能写。比如，上面的 v 这个局部变量，它只能进行 get() 操作，不能进行 add() 操作。

最后，还是要建议大家使用泛型，如官方文档所说的，如果可以使用泛型的地方，尽量使用泛型。

毕竟它抽离了数据类型与代码逻辑，
本意是提高程序代码的简洁性和可读性，
并提供可能的编译时类型转换安全检测功能。
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,294评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,493评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,790评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,595评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,718评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,906评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,053评论 3赞 410
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,797评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,250评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,570评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,711评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,388评论 4赞 332
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,018评论 3赞 316
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,796评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,023评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,461评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,595评论 2赞 350

推荐阅读更多精彩内容

  • java 泛型
    泛型，一个孤独的守门者。 大家可能会有疑问，我为什么叫做泛型是一个守门者。这其实是我个人的看法而已，我的意思是说泛...
    jackcooper阅读 440评论 2赞 2
  • Kotlin教程（九）泛型
    写在开头：本人打算开始写一个Kotlin系列的教程，一是使自己记忆和理解的更加深刻，二是可以分享给同样想学习Kot...
    胡奚冰阅读 1,423评论 1赞 3
  • 醉后偶得
    足踏云台着霓裳， 欲览蓬莱点月光。 拈得洞庭斟美酒， 抚平泰岳做牙床。 掀倒峨眉寻蟋蟀， 沥干钱塘冲茶汤。 且执终...
    涤尘水月阅读 178评论 0赞 1
  • UIKit-UIViewController
    一、结构 按结构可以对iOS的所有ViewController分成两类： 1、主要用于展示内容的ViewContr...
    石丘阅读 492评论 1赞 4
  • 漂亮的
    . pretty . handsome . good-looking . gorgeous: g)ge . lov...
    享悦moonlight阅读 80评论 0赞 0