Java 泛型完全解读
对于泛型的使用我想大家都非常熟悉,但是对于类型擦除,边界拓展等细节问题,可能不是很清楚,所以本文会重点讲解一下;另外对泛型的了解其实可以看出,一个语言特性的产生逻辑,这对我们平时的开发也是非常有帮助的;
一、为什么会出现泛型
首先泛型并不是Java的语言特性,是直到 JDK1.5 才支持的特性(具体区别后面会讲到);那么在泛型出现之前是怎么做的呢?
List list = new ArrayList();
list.add("123");
String s = (String) list.get(0);
如上面代码所示,在集合里面需要我们自己记住放进去的是什么,取出来的时候再强转; 也就将这种类型转换的错误推迟到了运行时,即麻烦还不安全,所以才出现了泛型;
使用场景:泛型类,泛型接口,泛型方法;
public class Test<T>
public interface Test<T>
public <T> void test(T t)
二、泛型会带来什么样的问题
正如上面所讲泛型并不是 Java 一开始就具有的特性,所以在后来想要增加泛型的时候,就必须要兼容以前的版本,Sun 他们想到的折中解决方案就是类型擦除;意思就是泛型的信息只存在于编译期,在运行时期所有的泛型信息都被擦除了,就想没有一样;
List<String> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();
System.out.println(list1.getClass());
System.out.println(list2.getClass() == list1.getClass());
// 打印:
class java.util.ArrayList
true
可以看到 List<String>
和 List<String>
在运行时其实都是一样的,都是class java.util.ArrayList
;所以在使用泛型的时候需要牢记,在运行时期没有泛型信息,也无法获取任何有关参数类型的信息;所以凡是需要获取运行时类型的操作,泛型都不支持!
1. 不能用基本类型实例化类型参数
new ArrayList<int>(); // error
new ArrayList<Integer>(); // correct
因为类型擦除,会擦除到他的上界也就是 Object
;而 Java 的8个基本类型的直接父类是 Number
,所以基本类型不不能用基本类型实例化类型参数,而必须使用基本类型的包装类;
2. 不能用于运行时类型检查
t instanceof T // error
t instanceof List<T> // error
t instanceof List<String> // error
t instanceof List // correct
但是可以使用 clazz.isInstance();
进行补偿;
3. 不能创建类型实例
T t = new T(); // error
同样可以使用 clazz.newInstance();
进行补偿;
4. 不能静态化
private static T t; // error
private T t; // correct
private static List<T> list; // error
private static List<?> list; // correct
private static List<String> list; // correct
// e.g.
class Test<T> {
private T t;
public void set(T arg) { t = arg; }
public T get() { return t; }
}
因为静态变量在类中共享,而泛型类型是不确定的,所以泛型不能静态化;但是非静态的时候,编译期可以根据上下文推断出T
是什么,例如:
Test l = new Test();
System.out.println(l.get());
l.set("123");
System.out.println(l.get());
// javap -v 反编译
12: invokevirtual #15 // Method JDK/Test14_genericity$Test.get:()Ljava/lang/Object;
15: invokevirtual #16 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
18: aload_1
19: ldc #17 // String 123
21: invokevirtual #18 // Method JDK/Test14_genericity$Test.set:(Ljava/lang/Object;)V
24: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream;
// ---------------------------
Test l = new Test();
System.out.println(l.get());
l.set("123");
System.out.println(l.get());
// javap -v 反编译
12: invokevirtual #15 // Method JDK/Test14_genericity$Test.get:()Ljava/lang/Object;
15: invokevirtual #16 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
18: aload_1
19: bipush 123
21: invokestatic #17 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
根据上面的代码,可以很清楚的看到,编译器对非静态类型的推导;
另外 List<?>
和 List<String>
之所以是正确的,仍然是因为编译器可以在编译期间就能确定类型转换的正确性;
5. 不能抛出或捕获泛型类的实例
catch (T t) // error
class Test<T> extends Throwable // error
因为在捕捉异常时候需要运行时类信息,并且判断异常的继承关系,所以不能抛出或捕获泛型类的实例;
6. 不允许作为参数进行重载
void test(List<Integer> list)
void test(List<String> list)
因为在运行时期泛型信息被擦除,重载的两个方法签名就完全一样了;
7. 不能创建泛型数组
对于一点我觉得是最重要的,关于数组的介绍可以参考,Array 相关 ;
List<String>[] lists = new ArrayList<String>[10]; // error
List<String>[] lists1 = (List<String>[]) new ArrayList[10]; // correct
之所以不能创建泛型数组的主要原因:
- 数组是协变的,而泛型的不变的;
- 数组的
Class
信息是在运行时动态创建的,而运行时不能获取泛型的类信息;
根据上面的讲解可以看出所谓的擦除补偿或者擦除后的修正,其大体思路都是用额外的方法告知运行时的类型信息,可以是记录到局部变量,也可以是指定参数的确切类型(Array.newInstance(Class<?> componentType, int length)
);
三、边界拓展
基于安全的考虑 Java 泛型是不变的(避免取出数据时的类型转换错误);
List<Object> list = new ArrayList<String>(); // error
所以在使用集合类的时候,每个集合都需要强制指定确切类型就有点不方便,比如我想指定一个集合存放 A 以及 A 的子类;在这种情况下就引入了 extends,super,?
来拓展和管理泛型的边界;
1. 无界通配符 <?>
通配符主要用于泛型的使用场景(泛型一般有“声明”和“使用”两种场景);
通常情况下 <?>
和原生类型大致相同,就像 List
和 List<?>
的表现大部分都是一样的;但是要注意他们其实是有本质去别的,<?>
代表了某一特定的类型,但是编译器不知道这种类型是什么;而原生的表示可以是任何 Object
,其中并没有类型限制;
List<?> list = new ArrayList<String>(); // correct
list.add("34"); // error
String s = list.get(0); // error
Object o = list.get(0); // correct
boolean add(E e);
上面的代码很明确的反应了这一点(<?>
代表了某一特定的类型,但是编译器不知道这种类型是什么),
- 因为编译器不知道这种类型是什么,所以在添加元素的时候,当然也就不能确认添加的这个类型是否正确;当使用
<?>
的时候,代码中的add(E e)
方法,此时的E
会被替换为<?>
,实际上编译器为了安全起见,会直接拒绝参数列表中涉及通配符的方法调用;就算这个方法没有向集合中添加元素,也会被直接拒绝; - 当
List<?>
取出元素的时候,同样因为不知道这个特定的类型是什么,所以只能将取出的元素放在Object
中;或者在取出后强转;
2. 上界 <extends>
extends
,主要用于确定泛型的上界;
<T extends Test> // 泛型声明
<T extends Test & interface1 & interface2> // 声明泛型是可以确定多个上界
<? extends T> // 泛型使用时
界定的范围如图所示:
应当注意的是当extends
用于参数类型限定时:
List<? extends List> list = new ArrayList<ArrayList>(); // correct
list.add(new ArrayList()); // error
List l = list.get(0); // correct
ArrayList l = list.get(0); // error
上面的分析同无界通配符类似,只是 List l = list.get(0);
是正确的,是因为 <? extends List>
界定了放入的元素一定是 List
或者 list
的子类,所以取出的元素能放入 List
中,但是不能放入 ArrayList
中;
3. 下界 <super>
super
,主要用于确定泛型的下界;如图所示:
List<? super HashMap> list = new ArrayList<>(); // correct
LinkedHashMap m = new LinkedHashMap(); // correct
HashMap m1 = m; // correct
Map m2 = m; // correct
list.add(m); // correct
list.add(m1); // correct
list.add(m2); // error
Map mm = list.get(0); // error
LinkedHashMap mm1 = list.get(0); // error
根据图中的范围对照代码,就能很快发现Map
在List<? super HashMap>
的范围之外;而编辑器为了安全泛型下界集合取出的元素只能放在 Object
里面;
4. PECS
原则
PECS
原则是对上界和下界使用的归纳,即producer-extends, consumer-super
;结合上面的两幅图,表示:
extends
,只能读,相当于生产者,向外产出;super
,只能写,相当于消费者,只能接收消费;- 同时边界不能同时规定上界和下界,正如图所示,他们的范围其实是一样的,只是开口不一样;
5. 自限定类型
对于上面讲的泛型边界拓展,有一个很特别的用法,
class Test<T extends Test<T>> {}
public <T extends Comparable<T>> T max(List<T> list) {}
自限定类型可以通俗的解释,就是用自己限定自己,即自和自身相同的类进行某操作;如上面的 max
方法,就表示可以和自身进行比较的类型;
那么如果想要表达只要是同一祖先就能相互比较呢?
public <T extends Comparable<? super>> T max(List<? extends T> list) {}
<T extends Comparable<? super>>
:表明只要是同一祖先就能相互比较,<? extends T>
表明集合中装的都是同一祖先的元素;(出至《Effective Java》第 28 条)
总结
- 对于泛型的时候首先要很清楚的知道,在运行时没有任何泛型的信息,全部都被擦除掉了;
- 需要知道 Java 泛型做不到的事情;
- 需要知道怎么拓展边界,让泛型更加灵活;
- 另外所有的
Comparator、Comparable
都是消费者,应用super
;
Java 泛型完全解读的更多相关文章
- Java泛型经典文章收集
https://blog.csdn.net/s10461/article/details/53941091 Java泛型详解(从基础到入门)https://blog.csdn.net/jeffleo/ ...
- Java:泛型的理解
本文源自参考<Think in Java>,多篇博文以及阅读源码的总结 前言 Java中的泛型每各人都在使用,但是它底层的实现方法是什么呢,为何要这样实现,这样实现的优缺点有哪些,怎么解决 ...
- Java泛型中的细节
Java泛型中的细节 如果没有泛型 学习Java,必不可少的一个过程就是需要掌握泛型.泛型起源于JDK1.5,为什么我们要使用泛型呢?泛型可以使编译器知道一个对象的限定类型是什么,这样编译器就可以在一 ...
- Java泛型的历史
为什么Java泛型会有当前的缺陷? 之前的章节里已经说明了Java泛型擦除会导致的问题,C++和C#的泛型都是在运行时存在的,难道Java天然不支持“真正的泛型”吗? 事实上,在Java1.5在200 ...
- 浅析Java 泛型
泛型是JavaSE5引入的一个新概念,但是这个概念在编程语言中却是很普遍的一个概念.下面,根据以下内容,我们总结下在Java中使用泛型. 泛型使用的意义 什么是泛型 泛型类 泛型方法 泛型接口 泛型擦 ...
- Java:泛型基础
泛型 引入泛型 传统编写的限制: 在Java中一般的类和方法,只能使用具体的类型,要么是基本数据类型,要么是自定义类型.如果要编写可以应用于多种类型的代码,这种刻板的限制就会束缚很多! 解决这种限制的 ...
- java泛型基础
泛型是Java SE 1.5的新特性, 泛型的本质是参数化类型, 也就是说所操作的数据类型被指定为一个参数. 这种参数类型可以用在类.接口和方法的创建中, 分别称为泛型类.泛型接口.泛型方法. Ja ...
- 使用java泛型设计通用方法
泛型是Java SE 1.5的新特性, 泛型的本质是参数化类型, 也就是说所操作的数据类型被指定为一个参数. 因此我们可以利用泛型和反射来设计一些通用方法. 现在有2张表, 一张user表和一张stu ...
- 关于Java泛型的使用
在目前我遇到的java项目中,泛型应用的最多的就属集合了.当要从数据库取出多个对象或者说是多条记录时,往往都要使用集合,那么为什么这么使用,或者使用时有什么要注意的地方,请关注以下内容. 感谢Wind ...
随机推荐
- 【转】Javascript全局变量var与不var的区别
相信你对全局变量一定不陌生,在函数作用域里用a=1这种形式定义的变量会是一个全局变量,在全局作用域里,用下面3种形式都可以创建对全局可见的命名: <script> var a = 1; b ...
- Java开源生鲜电商平台-订单表的设计(源码可下载)
Java开源生鲜电商平台-订单表的设计(源码可下载) 场景分析说明: 买家(餐馆)用户,通过APP进行选菜,放入购物车,然后下单,最终支付的流程,我们称为下单过程. 买家可以在张三家买茄子,李四家买萝 ...
- 深入浅出 TCP/IP 协议
TCP/IP 协议栈是一系列网络协议的总和,是构成网络通信的核心骨架,它定义了电子设备如何连入因特网,以及数据如何在它们之间进行传输.TCP/IP 协议采用4层结构,分别是应用层.传输层.网络层和链路 ...
- PAT1070:Mooncake
1070. Mooncake (25) 时间限制 100 ms 内存限制 65536 kB 代码长度限制 16000 B 判题程序 Standard 作者 CHEN, Yue Mooncake is ...
- jndi通俗理解以及它的指令缺陷
jndi(java naming directory interface),可以把JNDI看成一个全局的目录服务接口,实现了这个接口的类可以提供你想要的东西,不管这个东西是什么,只要注册到了目录中就可 ...
- AtomicInteger类的使用
AtomicInteger介绍 AtomicInteger是一个提供原子操作的Integer类,通过线程安全的方式操作加减. AtomicInteger使用场景 AtomicInteger提供原子操作 ...
- c++右值引用以及使用
前几天看了一篇文章<4行代码看看右值引用> 觉得写得不错,但是觉得右值引用的内容还有很多可以去挖掘学习,所以总结了一下,希望能对右值引用有一个更加深层次的认识 一.几个基本概念 1.1左值 ...
- (WCF初体验)WCF的认证和消息保护
最近做WCF开发,有个需求是在服务端做认证,网上查资料了解到可以用UserName和Password 来做认证,只需要写好配置文件和在服务端写好验证类就行了,但是网上普遍的博文都是需要用证书,而我自己 ...
- 聊一聊顺序消息(RocketMQ顺序消息的实现机制)
当我们说顺序时,我们在说什么? 日常思维中,顺序大部分情况会和时间关联起来,即时间的先后表示事件的顺序关系. 比如事件A发生在下午3点一刻,而事件B发生在下午4点,那么我们认为事件A发生在事件B之前, ...
- React,Node.js,Vue,Webkit技术内幕