泛型趣谈

Java中的泛型带来了什么好处？规约。就像接口定义一样，可以帮助对于泛型类型和对象的使用上，保证类型的正确性。如果没有泛型的约束，程序员大概需要在代码里面使用大量的类型强制转换语句，而且需要非常清楚没有标注的对象实际类型，这是容易出错的、恼人的。但是话说回来，泛型可不只有规约，还有很多有趣的用法，容我一一道来。

 

泛型擦除

Java的泛型在编译阶段实际上就已经被擦除了（这也是它和C#泛型最本质的区别），也就是说，对于使用泛型的定义，对于编译执行的过程，并没有任何的帮助（有谁能告诉我为什么按着泛型擦除来设计？）。所以，单纯利用泛型的不同来设计接口，会遇到预期之外的问题，比如说：

publicinterface Builder<K,V> {    publicvoid add(List<K> keyList);    publicvoid add(List<V> valueList);}

想这样设计接口？仅仅靠泛型类型的不同来设计重载接口？那是痴人说梦。但是如果代码变成这样呢？

publicclass GenericTypes {     publicstatic String method(List<String> list) {        System.out.println("invoke method(List<String> list)");        return"";    }     publicstatic int method(List<Integer> list) {        System.out.println("invoke method(List<Integer> list)");        return1;    }     publicstatic void main(String[] args) {        method(newArrayList<String>());        method(newArrayList<Integer>());    }}

这个情况就有点特殊了，Sun的Javac编译器居然可以通过编译，而其它不行，这个例子来自IcyFenix的文章，有兴趣不妨移步参阅IcyFenix的文章以及下面的讨论。

 

方法泛型

在JDK的java.util.List接口里面，定义了这样一个方法：

publicinterface List<E> extendsCollection<E> {    <T> T[] toArray(T[] a);}

事实上，这个方法泛型T表示的是任意类型，它可是和此例中的接口/类泛型E毫不相干啊。

如果我去设计方法，我可能写成这样：

<T> T[] toArray();

其实这个T[ ] a参数的作用也容易理解：

1. 确定了数组类型；
2. 如果给定的数组a能够容纳得下结果，就会把结果放进a里面（JDK的注释有说明“If the list fits in the specified array, it is returned therein.”），同时也把a返回。

如果没有这个T[ ] a参数的话，光光定义一个方法泛型<T>是没有任何意义的，因为这个T是什么类型完全是无法预料的，例如：

publicclass Builder {    public<E> E call(){        returnnull;    }         publicstatic void main(String[] args) {        String s = newBuilder().call(); // ①        Integer i = newBuilder().call(); // ②        newBuilder().<String>call(); // ③12    }}

可以看到，call()方法返回的是类型E，这个E其实没有任何约束，它可以表示任何对象，但是代码上不需要强制转换就可以赋给String类型的对象s（①），也可以赋给Integer的对象i（②），甚至，你可以主动告知编译器返回的对象类型（③）。

 

链式调用

看看如下示例代码：

publicclass Builder<S> {    public<E> Builder<E> change(S left, E right){        // 省略实现    }         publicstatic void main(String[] args) {        newBuilder<String>().change("3",3).change(3,3.0f).change(3.0f,3.0d);    }}

同样一个change方法，接收的参数变来变去的，上例中方法参数从String-int变到int-float，再变为float-double，这样的泛型魔法在设计链式调用的方法的时候，特别是定义DSL语法的时候特别有用。

 

使用问号 

其实问号帮助表示的是“通配符类型”，通配符类型 List<?> 与原始类型 List 和具体类型 List<String>都不相同，List<?>表示这个list内的每个元素的类型都相同，但是这种类型具体是什么我们却不知道。注意，List<?>和List<Object>可不相同，由于Object是最高层的超类，List<Object>表示元素可以是任何类型的对象，但是List<?>可不是这个意思。

来看一段有趣的代码：

classWrapper<E> {    privateE e;    publicvoid put(E e) {        this.e = e;    }         publicE get(){        returne;    }} publicclass Builder {    publicvoid check(Wrapper<?> wrapper){        System.out.println(wrapper.get());// ①        wrapper.put(newObject()); // ② wrong!        wrapper.put(wrapper.get());// ③ wrong!        wrapper.put(null);// ④ right!    }}

Wrapper的类定义里面指定了它包装了一个类型为E的对象，但是在另一个使用它的类Builder里面，指定了Wrapper的泛型参数是?，这就意味着这个被包装的对象的类型是完全不可知的：

• 现在我可以调用Wrapper的get方法把对象取出来看看（①），
• 但是我不能放任意类型确定的对象进去，Object也不行（②），
• 即便是从wrapper里面get出来也不行（编译器太不聪明了是吧？③）
• 可奇葩的是，放一个null是可以被允许的，因为null根本就不是任何一个类型的对象（④，注意，不能放int这类的原语类型，虽然它不是对象，但因为它会被自动装箱成Integer，从而变成具体类型，所以是会失败的）。

现在思考一下，如果要表示这个未知对象是某个类的子类，上面代码的Wrapper定义不变，但是check方法写成：

publicvoid check(Wrapper<? extendsString> wrapper){wrapper.put(newString());}

这样呢？

……

依然报错，因为new String()确实是String的子类（或它自己）的对象，一点都没错，但是它可不见得和同为String子类（或它自己）的“?”属于同一个类型啊！

如果写成这样呢（注意extends变成了super）？

publicvoid check(Wrapper<? superString> wrapper){wrapper.put(newString());}

这次对了，为什么呢？

……

因为wrapper要求put的参数“?”必须是String的父类（或它自己），而不管这个类型如何变化，它一定是new String()的父类（或它自己）啊！

 

泛型递归

啥，泛型还能递归？当然能。而且这也是一种好玩的泛型使用：

classWrapper<E extendsWrapper<E>> implementsComparable<Wrapper<E>> {     @Override    publicint compareTo(Wrapper<E> wrapper) {        return0;    } }

好玩吧？泛型也能递归。这个例子指的是，一个对象E由包装器Wrapper所包装，但是，E也必须是一个包装器，这正是包装器的递归；同时，包装器也实现了一个比较接口，使得两个包装器可以互相比较大小。

 

别晕！泛型只不过是一个普普通通的语言特性，但是也挺有趣的。

转自http://raychase.iteye.com/blog/2001539