几年前当Java5还未正式发布的时候,看到过一些人写的介绍Tiger中的新特性,当时对我第一感觉冲击最大的就是泛型(generics)和注释(annotation),因为它们直接影响了我们编码的语法习惯。

在后来的使用过程中,对于泛型一直没有特别深入的使用过,没有遇到那样的需求和场景。只需要了解Java中的泛型是编译期的,运行期被“擦拭”掉了;然后还有几种通配符的表示就足够了。

直到一天我在查看Java5中Enum的源代码时,发现它是这么定义的:

  1. public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {

这个类似递归结构的 Enum<E extends Enum<E>> 究竟表达什么意思?

随后我又看到了在Collections工具类中的max 方法:

怎么TMD还会有这么复杂的泛型表达式!?

(幸好的是这种情况在我们实际开发过程中不多见,甚至不应该见到,大概只有像JDK这种为了保留对老版本的兼容才会设计出这么复杂的泛型表达式出来。)

上面的问题,你可以通过:http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf 来获取答案,中文版的在:http://blog.csdn.net/explorers/archive/2005/08/15/454837.aspx

这篇泛型指南的文章,非常详细。

或许你看了上面的文章,依然心存疑虑。我下面的内容则是对这篇文档的一些补充(会和这篇文档有点重合)。

在回到我之前抛出的问题上:

  1. public static void foo(List<? extends Number> l){
  2. l.add(new Integer(2));  // 编译通过么? Why ?
  3. }
  4. public static void bar(List<? super Number> l){
  5. l.add(new Integer(2));  // 编译通过么? Why ?
  6. l.add(new Float(2));    // ok?
  7. }

这里主要说说 <? extends T> 和 <? super T> 这两种通配符对于方法参数的使用原则。

即 PECS 原则 (producser-extends, consumer-super)  或者也叫 Get and Put 原则

当没有使用通配符的情况下,我们定义一个方法:

  1. public static <E> void test(List<E> l){
  2. E e = l.get(0);
  3. l.set(0, e);
  4. }

我们从List中 get和set都没有问题,因为这个E 它的类型是某种明确的类型。

而当使用通配符时来描述参数时,就有些不同了。

我们先定义一下两种通配符:

<? extends E> 是 Upper Bound(上限) 的通配符

<? super E> 是 Lower Bound(下限) 的通配符

1) 当使用 Upper Bound 通配符时:

<?> 是 <? extends Object> 的简写。(关于<?>是否和<? extends Object>完全等价,在结束的时候来描述)

在eclipse里错误提示为: The method set(int, capture#2-of ?) in the type List<capture#2-of ?> is not applicable for the arguments (int, Object)

注: <capture#2-of ?> 是一个占位符,表示编译器对通配符的捕获,更多见:

http://www.ibm.com/developerworks/cn/java/j-jtp04298.html

set报错的原因是因为此时方法中的类型是不可具体化的(reified),你可以传递一个String,Number,Book,等任何继承自Object的类作为List的参数类型给test方法,而list要求集合中的类型必须是一致的,set的时候没有办法保证set进去的数据类型是否和list中原本的类型一致,比如你传给test方法的是 List<Book>, 那么在方法中set进去一个Object显然类型就不一致了。

这也是通配符带来灵活性的同时所要付出的代价。

结论:使用了 <? extends E> 这样的通配符,test方法的参数list变成了只能get不能set(除了null) 或者不严谨的说它变成了只读参数了, 有些类似一个生产者,提供数据。

  1. 2) 当使用 Lower Bound 的通配符时:
  2. public static void test(List<? super Number> list){
  3. Number n = list.get(0);             // 编译错误
  4. Object o = list.get(0);             // OK
  5. list.set(0, new Object());      // 编译错误
  6. list.set(0, new Long(0));       // OK
  7. list.set(0, new Integer(0));    // OK
  8. }

这时get只能get出最宽泛的父类型,即Object。

这时set的时候,必须是Number或Number的子类。

原因和上面的get类似。

结论: 使用了<? super E> 这种通配符,test方法的参数list的get受到了很大的制约,只能最宽泛的方式来获取list中的数据,相当于get只提供了数据最小级别的访问权限(想想,你可能原本是放进去了一个Book,却只能当作Object来访问)。

它更多适合于set的使用场景,像是一个消费者,主要用来消费数据。

上面便是对通配符的使用原则的说明,简单的说 PECS原则是指导我们在泛型方法中使用通配符的直接原则。参数作为生产者使用<? extends E>,作为消费者时使用<? super E> 。

那么说完了 PECS原则,我们再回过头来分析那两个复杂的泛型表达式是怎么含义

1) class Enum<E extends Enum<E>>

它确实是一个 “递归类型限制”(recursive type bound)

要说明白这个问题,我们要先明白2点:

a) Enum可以理解为一组同一类型的有限的数据集合;

b) Java对Enum中的数据类型要求必须也是枚举类型(即必须是继承Enum类的)。

对于 a) 我们先定义一个 Enum<T> 表明定义了T这种类型作为它内部的数据类型,这么看它就像个普通的集合。

再来根据b) 定义类型E,要求E必须是继承自 Enum<T>,便成了  <E extends Enum<T>>

实际上 E和T是一回事,它们是同一类型,所以它就是 <E extends Enum<E>>

暂停,可能我上面的表达不太合理可能会误人子弟,递归类型限制是有些抽象,它应该有严谨的数学描述,我想不清楚怎么表达,我先用另一个简单些例子来说明吧

public static <T extends Comparable<T>> T max(List<T> list)

这个方法用来获取list 中的最大值,它定义了一个 <T extends Comparable<T>> 的类型表达式

这个递归类型限制的表达式容易理解一些,

 <T extends Comparable<T>> 表示的是:针对可以与自身进行比较的每个类型T。

或者说,每个实现了Comparable<T>接口的类型T,比如 String 实现了 Comparable<String> , Long实现了Comparable<Long>等等

而Enum因为使用enum关键字的原因,让我们忽略了它底层的实现其实也是

class EnumSample extends Enum<EnumSample> 这一事实,

比如 我们定义了 BoundKind 这样的一个枚举:

public enum BoundKind{ }

编译器会转换为:

public final class BoundKind extends java.lang.Enum<BoundKind>

看到了,这和  String implements Comparable<String> 类似

这样我们套回到<E extends Enum<E>> 就是 <BoundKind extends Enum<BoundKind>>

这下好理解了, <E extends Enum<E>> 就直接按字面理解:每个继承自Enum<E>的类型E,比如 BoundKind 继承了Enum<BoundKind>

通过与<T extends Comparable<T>>的对比,我们可以理解 <E extends Enum<E>>了。

那现在我们再回到Collections工具类中的max 方法:

我们先简化一下这个表达式,看看

<T extends Comparable<? super T>> 怎么理解?

既然 <T extends Comparable<T>> 我们都理解了,把Comparable<T> 改为

Comparable<? super T> 也没什么费解的

在《Java1.5 Generics Tutorial》一文中的解释是:

精确的(exactly)和自己能比较是不需要的。所需要的 是T能够和它的父类中的一个进行比较。

而《Effictive Java》第二版中对此是用 PECS原则来解释的:

下面是修改过的使用通配符类型的声明:

为了从初始声明中得到修改后的版本,要应用PECS转换两次,最直接的是运用到参数List。它产生T实例,因此将类型从List<T>改为List<? extends T>。(ok好理解)

。。。。。。

更灵活的是运用到类型参数T。最初T 被指定用来扩展Comparable<T>,但是T的comparable消费T实例(并产生表示顺序关系的整值)。因此,参数化类型Comparable<T>被有限制通配符类型Comparable<? super T>取代。comparable始终是消费者,因此使用时始终应该是Comparable<? super T> 优先于 Comparable<T>。

蓝色粗体的那句翻译的不好。还是看一下代码来理解吧:

  1. public static <T extends Comparable<? super T>> T max(Collection<? extends T> coll) {
  2. 1     Iterator<? extends T> i = coll.iterator();
  3. 2     T candidate = i.next();
  4. 3     while (i.hasNext()) {
  5. 4         T next = i.next();
  6. 5         if (next.compareTo(candidate) > 0) // here comparaTo
  7. 6             candidate = next;
  8. 7     }
  9. 8     return candidate;
  10. 9 }

第5行,Bloch认为 next.compareTo(cand) 是一句消费操作,在消费一个candidate对象时,根据PECS原则,candidate的类型应该使用 <? super T> 来提高它的灵活性。

我觉得Bloch将第5行当作消费操作挺别扭的,我个人偏向《Java1.5 Generics Tutorial》中的解释。

但归根到底,都是降低限制,提高比较时的灵活性。

最后,我们再来完整的理解:<T extends Object & Comparable<? super T>>

就只是比 <T extends Comparable<? super T>> 多了一个限制(bounds)。

Object & Comparable<? super T> 是一个多限定(multiple bounds)的用法,

语法为: T1 & T2 … & Tn

一个有多个界限的类型的参数是所有界限中列出来的类型的子类。当多个界限被使用的时候,界限中的第一个类型被用作这个类型参数的erasure。

最终这个方法的返回值,按照第一个限定,擦拭为Object类型了。这是因为在以前版本中此方法就是返回的Object类型,需要兼容。

(此句话随口而说,验证发现有误,发现类型推导比较复杂,就不去理解了)

因为多限定(multiple bounds)的存在,泛型方法中又对应的增加了一个很不优雅的调用方式。下面用一段代码来说明:

  1. public class GenericsTest {
  2. static class Book {};
  3. static class StoryBook extends Book implements Comparable<StoryBook> {
  4. @Override
  5. public int compareTo(StoryBook o) {
  6. return 0; //FIXME
  7. }};
  8. static class TechBook extends Book implements Comparable<TechBook> {
  9. @Override
  10. public int compareTo(TechBook o) {
  11. return 0; //FIXME
  12. }};
  13. public static <E> Set<E> merge(Set<? extends E> s1, Set<? extends E> s2) {
  14. HashSet<E> newSet = new HashSet<E>(s1);
  15. newSet.addAll(s2);
  16. return newSet;
  17. }
  18. public static void main(String[] args) {
  19. HashSet<StoryBook> s1 = new HashSet<StoryBook>();
  20. HashSet<TechBook> s2 = new HashSet<TechBook>();
  21. Set<Book> sb = merge(s1, s2); // 错误
  22. // 需通过显式的类型参数(explicit type parameter)来告诉它要使用哪种类型
  23. Set<Book> bs = GenericsTest.<Book>merge(s1,s2); //OK
  24. // 或者
  25. Set<Comparable<?>> s = GenericsTest.<Comparable<?>>merge(s1,s2);
  26. }
  27. }

上面直接调用merge(s1,s2) 那行代码错误的提示信息:

Type mismatch: cannot convert from  Set<GenericsTest.Book&Comparable<?>> to Set<GenericsTest.Book>

这归于泛型的类型推导(type inference),当无法推导出明确的类型时,就需要显式的描述,如上面代码中红色粗体字。

后注:

有关于 <?> 与 <? extends Object>是否是一回事

今天中午发现同事桌上有本《Java编程思想》第四版,随手翻了一下,发现泛型一章的介绍中,

有句描述:“UnboundedWildcards.java 展示了编译器处理List<?>和List<? Extends Object>时是不同的。”

这让我奇怪,查看了一下它的代码,主要因为是对于Raw类型的造型为泛型时的警告信息不同。

将一个Raw的ArrayList造型给 List<?> 没有问题,而给List<? Extends Object>却会有警告。

在网上查了一下,发现对于<?>与<? extends Object>是否等同,是有些不同意见的。

http://mail.openjdk.java.net/pipermail/compiler-dev/2008-April/000316.html

http://bugs.sun.com/view_bug.do?bug_id=6559175

这个报告里,有两段代码反映了两者的不同:

  1. (1)
  2. public static void main(String[] args)  {
  3. Object  customer  = null;
  4. foo((List<? extends String>) customer ); //[1]
  5. foo((List<? extends Object>) customer ); //[2] 编译有警告
  6. foo((List<?>) customer ); //[3]  编译没有警告
  7. }
  8. public static void foo(List<?> list) {
  9. }
  10. (2)
  11. Object o2 = new List<?>[3];   // 编译居然OK,估计直接当作Raw处理了
  12. Object o3 = new List<? extends Object>[3]; // 报错

上面两段代码,表明了当与Raw类型造型时,<?>在编译器的处理方式的确与<? Extends Object>有所不同,根据场景它可能被编译器忽略掉泛型信息而直接当作Raw类型,而<? Extends Object>则不会。

但这种差异,有些吹毛求疵,除了跟Raw类型转换方面存在差异,在语义上两者可以认为是完全等同的,

见:http://bugs.sun.com/view_bug.do?bug_id=6480391

The introduction of the capture conversion simplified a lot of things. One of the things it did is make "?" equivalent to "? extends Object". 
Unfortunately, JLS3 doesn't say they are equivalent.
SUN的开发人员回复说:
? should be considered equivalent to ? extends Object. I will note this at the end of the text about bounds for wildcards in 4.5.1.
……
Hence, Foo<?> is semantically equivalent to Foo<? extends Object>

java泛型小问题的更多相关文章

  1. java泛型小总结

    一. 泛型概念的提出(为什么需要泛型)? 首先,我们看下下面这段简短的代码: public class GenericTest { public static void main(String[] a ...

  2. 遇到个小问题,Java泛型真的是鸡肋吗?

    今天遇到一个小问题,让我感觉Java的泛型(因为背负了历史的包袱导致的)有点鸡肋啊. 我们经常会遇到要一些自定义的key-value字符串,比如: "key1:1k;key2:2;key3: ...

  3. 一个小栗子聊聊JAVA泛型基础

    背景 周五本该是愉快的,可是今天花了一个早上查问题,为什么要花一个早上?我把原因总结为两点: 日志信息严重丢失,茫茫代码毫无头绪. 对泛型的认识不够,导致代码出现了BUG. 第一个原因可以通过以后编码 ...

  4. Java泛型总结

    1. 什么是泛型?泛型(Generic type 或者 generics)是对 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类.可以把类型参数看作是使用参数化类型时指定的类型的 ...

  5. java泛型的讲解

    java泛型 什么是泛型? 泛型(Generic type 或者 generics)是对 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类.可以把类型参数看作是使用参数化类型时指 ...

  6. java泛型 之 入门(interface)

    一:泛型简单介绍: (1)所谓泛型,就是变量类型的參数化. 泛型是JDK1.5中一个最重要的特征.通过引入泛型,我们将获得编译时类型的安全和执行时更小的抛出ClassCastException的可能. ...

  7. Java 泛型 协变性、逆变性

    Java 泛型 协变性.逆变性 @author ixenos 摘要:协变性.协变通配符.协变数组.协变返回值 协变性.逆变性和无关性 在面向对象的计算机程序语言中,经常涉及到类型之间的转换,例如从具体 ...

  8. java 泛型详解(普通泛型、 通配符、 泛型接口,泛型数组,泛型方法,泛型嵌套)

    JDK1.5 令我们期待很久,可是当他发布的时候却更换版本号为5.0.这说明Java已经有大幅度的变化.本文将讲解JDK5.0支持的新功能-----Java的泛型.  1.Java泛型  其实Java ...

  9. java泛型(二)、泛型的内部原理:类型擦除以及类型擦除带来的问题

    微信公众号[程序员江湖] 作者黄小斜,斜杠青年,某985硕士,阿里 Java 研发工程师,于 2018 年秋招拿到 BAT 头条.网易.滴滴等 8 个大厂 offer,目前致力于分享这几年的学习经验. ...

随机推荐

  1. js一些小知识点

    1.isNaN(),里面传一个参数,用来判断传入的值是否是数字.可以用来做一些简单的表单判断. 2.用innerHTML属性可以操作(包括获取和设置)span的内容,实际上对所有非表单元素都可以用in ...

  2. webservice底层使用Socket进行网络调用

    服务端代码(其实tomcat的原理也是这样): 客户端代码:

  3. 为什么要lock,lock了什么?

    当我们使用线程的时候,效率最高的方式当然是异步,即各个线程同时运行,其间不相互依赖和等待.但当不同的线程都需要访问某个资源的时候,就需要同步机制了,也就是说当对同一个资源进行读写的时候,我们要使该资源 ...

  4. [jquery备忘]

    has :包含,找元素里面的子元素(单个) <div><span>123</span></div> $('div').has('span').css() ...

  5. 2016GIAC全球互联网架构大会日程分享

    GIAC全球互联网架构大会是中国互联网技术领域一年一度的行业盛事,每年从互联网架构最热门高压应对.云计算.大数据.机器学习.分布式架构等领域甄选前沿的有典型代表的技术创新及研发实践的架构案例,分享他们 ...

  6. JavaEE 配置文件 应用首选项存储

    JavaEE 配置文件 应用首选项存储 @author ixenos 什么是首选项? 首选项Preferences 指配置信息 首选项存储就是指对配置信息的存储   有什么方式存储? 有两种,一种存于 ...

  7. C#获取数字证书

    string Thumbprint = "C2489D912F247C187AA14B1291A6fB612281225D"; X509Store store = new X509 ...

  8. Python之线程&进程

    线程: 线程是操作系统能够进行运算调度的最小单位.它被包含在进程之中,是进程中的实际运作单位.一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务. thr ...

  9. ESFramework 4.0 进阶(04)-- 驱动力:通信引擎(下)

    在ESFramework 4.0 进阶(03)-- 驱动力:通信引擎(上)一文中,我们对ESFramework提供的每一个通信引擎的接口都做了详细了说明,这篇文章我们将继续探讨这些接口的实现类 -- ...

  10. 关于python的类方法、实例方法和静态方法区别

    python的类方法需要在方法前面加装饰器:@classmethod ,静态方法是在方法前面加装饰器:@staticmethod. 类方法.类属性是属于类自身,属于类自身的命名空间,和实例方法.实例属 ...