泛型

最新推荐文章于 2023-11-27 08:52:01 发布

rabbit_in_android

最新推荐文章于 2023-11-27 08:52:01 发布

阅读量674

点赞数 4

CC 4.0 BY-SA版权

分类专栏：进击的兔子之JAVA基础

本文链接：https://blog.youkuaiyun.com/rabbit_in_android/article/details/50018723

进击的兔子之JAVA基础专栏收录该内容

40 篇文章

订阅专栏

Java的泛型机制是与C++不同的，它采用的是擦除机制，所以泛型在java中是一种折中的处理方案，而不是java本身的一种特性。

由于采用的擦除机制，所以在运行时，对使用泛型的对象进行类型判断是有很严重的问题的。例如:

[java]view plaincopyprint? 
   
 List list1=new ArrayList();  
 List<String> list2=new ArrayList<String>();  

list1和list2在运行时进行的类型判定，特别在反射操作时，这两个是相等的。

1. 概述
在引入范型之前，Java类型分为原始类型、复杂类型，其中复杂类型分为数组和类。引入范型后，一个复杂类型
就可以在细分成更多的类型。
例如原先的类型List，现在在细分成List<Object>, List<String>等更多的类型。
注意，现在List<Object>, List<String>是两种不同的类型，
他们之间没有继承关系，即使String继承了Object。下面的代码是非法的
List<String> ls = new ArrayList<String>();
List<Object> lo = ls;

以下代码无效：
List apples;
List fruits = ...;
Fruits= apples;

为什么一箱苹果就不是一箱水果了呢？现在假设以上操作允许，那么下面的操作会出错误
fruits.add(new Strawberry());

一个List中装入了各种不同类型的子类水果，这显然是不可以的，因为我们在取出List中的水果对象时，就分不清楚到底该转型为苹果还是草莓了。所以，泛型在使用时并不考虑类与类之间的继承关系
在引入范型之前，要在类中的方法支持多个数据类型，就需要对方法进行重载，在引入范型后，可以解决此问题
（多态），更进一步可以定义多个参数以及返回值之间的关系。
例如
public void write(Integer i, Integer[] ia);
public void write(Double d, Double[] da);
的范型版本为
public <T> void write(T t, T[] ta);

泛型的好处：提高的代码的复用性，同时泛型提供了类型检查，减少了数据的类型转换，同时保证了类型安全

在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。让编译器保留参数的类型信息，执行类型检查，执行类型转换操作：编译器保证了这些类型转换的绝对无误。
相对于依赖程序员来记住对象类型、执行类型转换——这会导致程序运行时的失败，很难调试和解决，而编译器能够帮助程序员在编译时强制进行大量的类型检查，发现其中的错误。

没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

消除强制类型转换。泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。

1 List box = ...;
2 Apple apple = box.get(0);
上面的代码自身已表达的很清楚：box是一个装有Apple对象的List。get方法返回一个Apple对象实例，这个过程不需要进行类型转换。
没有泛型，上面的代码需要写成这样：
1 List box = ...;
2 Apple apple = (Apple) box.get(0);

？extends通配符，向上造型一个泛型对象的引用
? extends XX，XX 类是用来限定通配符的上界，XX 类是能匹配的最顶层的类，它只能匹配 XX 类以及 XX 类的子类。

? super通配符，向下造型一个泛型对象的引用
? super XX，XX 类是用来限定通配符的下界，XX 类是能匹配的最底层的类，它只能匹配 XX 类及子类。

对于不同传入的类型实参，生成的相应对象实例的类型是不是一样的呢？

 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 }

由此，我们发现，在使用泛型类时，虽然传入了不同的泛型实参，但并没有真正意义上生成不同的类型，传入不同泛型实参的泛型类在内存上只有一个，即还是原来的最基本的类型（本实例中为Box），当然，在逻辑上我们可以理解成多个不同的泛型类型。

究其原因，在于Java中的泛型这一概念提出的目的，导致其只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。

对此总结成一句话：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

1.什么是类型擦除？

在java里面泛型其实是伪泛型，因为他都只是在编译器里面实现的，在jvm里面是没有泛型的概念。

我们看下面的代码：

[java]view plaincopy 
   
 package com.ray.ch11;  
   
 import java.util.ArrayList;  
   
 public class Test {  
     public static void main(String[] args) {  
         ArrayList<Integer> list1 = new ArrayList<Integer>();  
         ArrayList<String> list2 = new ArrayList<String>();  
         System.out.println(list1.getClass() == list2.getClass());  
     }  
 }  

输出：

true

为什么两个list对应的Class对象是一致的呢？因为在jvm层面，他只看到List，没有里面的类型。

也就是，泛型里面的类型信息被擦掉了，这就是所谓的类型擦除。

5. 实现原理

5.1. Java范型时编译时技术，在运行时不包含范型信息，仅仅Class的实例中包含了类型参数的定义信息。
泛型是通过java编译器的称为擦除(erasure)的前端处理来实现的。你可以（基本上就是）把它认为是一个从源
码到源码的转换，它把泛型版本转换成非泛型版本。
基本上，擦除去掉了所有的泛型类型信息。所有在尖括号之间的类型信息都被扔掉了，因此，比如说一个
List<String>类型被转换为List。所有对类型变量的引用被替换成类型变量的上限(通常是Object)。而且，
无论何时结果代码类型不正确，会插入一个到合适类型的转换。
     <T> T badCast(T t, Object o) {
         return (T) o; // unchecked warning
       }
类型参数在运行时并不存在。这意味着它们不会添加任何的时间或者空间上的负担，这很好。不幸的是，这也意味
着你不能依靠他们进行类型转换。

5.2.一个泛型类被其所有调用共享
下面的代码打印的结果是什么？
       List<String> l1 = new ArrayList<String>();
       List<Integer> l2 = new ArrayList<Integer>();
       System.out.println(l1.getClass() == l2.getClass());
或许你会说false，但是你想错了。它打印出true。因为一个泛型类的所有实例在运行时具有相同的运行时类(class)，
而不管他们的实际类型参数。
事实上，泛型之所以叫泛型，就是因为它对所有其可能的类型参数，有同样的行为；同样的类可以被当作许多不同
的类型。作为一个结果，类的静态变量和方法也在所有的实例间共享。这就是为什么在静态方法或静态初始化代码
中或者在静态变量的声明和初始化时使用类型参数（类型参数是属于具体实例的）是不合法的原因。

5.3. 转型和instanceof
泛型类被所有其实例(instances)共享的另一个暗示是检查一个实例是不是一个特定类型的泛型类是没有意义的。
       Collection cs = new ArrayList<String>();
       if (cs instanceof Collection<String>) { ...} // 非法
类似的，如下的类型转换
Collection<String> cstr = (Collection<String>) cs;

泛型
术语意思：是适用于许多的类型，即使代码可以应用于多种类型。
目的：希望类或者方法能够具备最广泛的表达能力，并且将错误检测移入到编译期间。
核心概念：告诉编译器想使用什么类型，然后编译器帮你处理好一切细节。
举个例子：

<code class="hljs lasso has-numbering" style="display: block; padding: 0px; background-color: transparent; color: inherit; box-sizing: border-box; font-family: 'Source Code Pro', monospace;font-size:undefined; white-space: pre; border-top-left-radius: 0px; border-top-right-radius: 0px; border-bottom-right-radius: 0px; border-bottom-left-radius: 0px; word-wrap: normal; background-position: initial initial; background-repeat: initial initial;"><span class="hljs-literal" style="color: rgb(0, 102, 102); box-sizing: border-box;">void</span> test(){
        <span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box;">List</span><span class="hljs-subst" style="color: rgb(0, 0, 0); box-sizing: border-box;"><</span>User<span class="hljs-subst" style="color: rgb(0, 0, 0); box-sizing: border-box;">></span> listTest <span class="hljs-subst" style="color: rgb(0, 0, 0); box-sizing: border-box;">=</span> <span class="hljs-literal" style="color: rgb(0, 102, 102); box-sizing: border-box;">new</span> ArrayList<span class="hljs-subst" style="color: rgb(0, 0, 0); box-sizing: border-box;"><</span>User<span class="hljs-subst" style="color: rgb(0, 0, 0); box-sizing: border-box;">></span>();
        listTest<span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box;">.</span>add(<span class="hljs-literal" style="color: rgb(0, 102, 102); box-sizing: border-box;">new</span> User());<span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//正确</span>
        listTest<span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box;">.</span>add(<span class="hljs-literal" style="color: rgb(0, 102, 102); box-sizing: border-box;">new</span> Dog());<span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">//错误  在编译期间就提示出来 所以细节由编译器处理</span>
    }</code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li></ul>

擦除
Java泛型是通过使用擦除来完成的，这意味着当你使用泛型的时候，任何具体的参数类型都会被擦除，占位符T（一般是T 随便写）将会被Object代替（如果有边界的话就是用边界代替，待会说）。
如之前的代码

<code class="hljs cs has-numbering" style="display: block; padding: 0px; background-color: transparent; color: inherit; box-sizing: border-box; font-family: 'Source Code Pro', monospace;font-size:undefined; white-space: pre; border-top-left-radius: 0px; border-top-right-radius: 0px; border-bottom-right-radius: 0px; border-bottom-left-radius: 0px; word-wrap: normal; background-position: initial initial; background-repeat: initial initial;"><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">class</span> Test<T> {
    <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">private</span> T t;
    <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">public</span> T <span class="hljs-title" style="box-sizing: border-box;">getT</span>() {
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">return</span> t;
    }
    <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">void</span> <span class="hljs-title" style="box-sizing: border-box;">setT</span>(T t) {
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">this</span>.t = t;
    }
}</code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li><li style="box-sizing: border-box; padding: 0px 5px;">8</li><li style="box-sizing: border-box; padding: 0px 5px;">9</li></ul>

擦除后

<code class="hljs cs has-numbering" style="display: block; padding: 0px; background-color: transparent; color: inherit; box-sizing: border-box; font-family: 'Source Code Pro', monospace;font-size:undefined; white-space: pre; border-top-left-radius: 0px; border-top-right-radius: 0px; border-bottom-right-radius: 0px; border-bottom-left-radius: 0px; word-wrap: normal; background-position: initial initial; background-repeat: initial initial;"><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">class</span> Test{
    <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">private</span> Object t;
    <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">public</span> Object <span class="hljs-title" style="box-sizing: border-box;">getT</span>() {
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">return</span> t;
    }
    <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">void</span> <span class="hljs-title" style="box-sizing: border-box;">setT</span>(Object t) {
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">this</span>.t = t;
    }
}</code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; background-color: rgb(238, 238, 238); top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); list-style: none; text-align: right;"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li><li style="box-sizing: border-box; padding: 0px 5px;">8</li><li style="box-sizing: border-box; padding: 0px 5px;">9</li></ul>

由上面的可以得知,例如
List和List在运行时是相同的类型即 List.getClass()==List.getClass()。