深入了解Java泛型(三) -- 泛型方法

前面提到的都是与类的泛型化相关的话题，不过方法也可以从泛型中受益，尤其是Helper类的工具方法这种"无状态"的方法更加合适。还是有几个话题可以进一步讨论下的。

1. 类型推导
所谓类型推导，就是编译器可以通过判断参数的类型来推导类型参数(泛型)的类型。这句话初看会发现非常绕口，举个例子就能很好的理解了。

public class GenericHelper {

	public static <E> Set<E> merge(Set<E> set1, Set<E> set2){
		Set<E> retSet = new HashSet<E>(set1);
		retSet.addAll(set2);
		return retSet;
	}
}

这个方法的目的是将set1和set2的元素进行合并。在使用这个方法的时候，如果传入的参数是Set<Integer>类型的，那么编译器就会自动推导出E的类型是Integer了。

这个特性可以使用在一种叫做"泛型静态工厂方法"的的编写上，比如下面的几个方法。

	public static <E> Set<E> createSet() {
		return new HashSet<E>();
	}

	public static <K, V> Map<K, Set<V>> createMap() {
		return new HashMap<K, Set<V>>();
	}

	public static void main(String[] args) {
		Map<String, Set<Integer>> str = createMap();
		Set<Integer> set = createSet();
		str.put("key", set);
	}

这里的一系列方法就是运用了类型推导的来使Map和Set的创建语句缩短，程序员都应该是懒人吗！呵呵。

这里，对于类型推导，还有一个比较重要的用法，就是"泛型单例工厂"。举个例子如下：

假设有一个如下的接口：

public interface NumberWrapper<T extends Number> {
	public double square(T num);
}

这个接口可以对Number的子类进行封装，它提供了一个方法可以输出值的平方。对于这样的Wrapper，我并不想对于每一个T都实例化一个相应的对象，那样有一些浪费，这时，就可以使用这个泛型单例工厂来生成支持不同T的单例。另外，因为NumberWrapper的泛型信息在运行时是会被擦除的，所以也没有必要对每一个T生成一个实例。泛型单例工厂的代码如下：

public class GenericFactory {

	private static NumberWrapper<Number> numWrapper = new NumberWrapper<Number>() {
		@Override
		public double square(Number num) {
			return num.doubleValue() * num.doubleValue();
		}
	};

	@SuppressWarnings("unchecked")
	public static <T extends Number> NumberWrapper<T> getWrapperInstance() {
		return (NumberWrapper<T>) numWrapper;
	}

	public static void main(String[] args) {
		NumberWrapper<Integer> integerWrapper = GenericFactory.getWrapperInstance();
		System.out.println(integerWrapper.square(2));

		NumberWrapper<Double> doubleWrapper = GenericFactory.getWrapperInstance();
		System.out.println(doubleWrapper.square(0.05));
	}

}

这里，有一个点要注意下，就是getWrapperInstance()方法的的类型转换，这里是一个NumberWrapper<Number>向NumberWrapper<T>的转换，这里，由于square()方法返回的仅仅是平方，这里是不会导致类型错误的，所以可以放心的禁止这条警告了。

程序的运行结果如下所示：

4.0
0.0025000000000000005

说明程序还是运行良好的。

2. 递归类型限制
所谓递归类型限制，是使用包含某个参数类型本身的表达式去限制参数的类型。比如java.util.Collections的max()方法，定义如下：

	public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) {
    	Iterator<? extends T> i = coll.iterator();
    	T candidate = i.next();

            while (i.hasNext()) {
    	    T next = i.next();
    	    if (next.compareTo(candidate) > 0)
    		candidate = next;
    	}
    	return candidate;
    }

这里面的具体实现先不用去关注。这里，类型参数的定义是T extends Object & Comparable<? super T>。T是要扩展自Comparable<? super T>的，这里就是一个递归类型限制。其实也好理解，比如String类就是Comparable<String>的子类，Integer是Comparable<Integer>的子类，只有类型是"可以比较的"才能去计算的最大值吗。

这个的用法不多，就不去仔细研究了，到真正会使用的时候再去研究也不晚，这就是所谓的"延迟加载"吧，呵呵。