前面提到的都是与类的泛型化相关的话题,不过方法也可以从泛型中受益,尤其是Helper类的工具方法这种"无状态"的方法更加合适。还是有几个话题可以进一步讨论下的。
1. 类型推导
所谓类型推导,就是编译器可以通过判断参数的类型来推导类型参数(泛型)的类型。这句话初看会发现非常绕口,举个例子就能很好的理解了。
这个方法的目的是将set1和set2的元素进行合并。在使用这个方法的时候,如果传入的参数是Set<Integer>类型的,那么编译器就会自动推导出E的类型是Integer了。
这个特性可以使用在一种叫做"泛型静态工厂方法"的的编写上,比如下面的几个方法。
这里的一系列方法就是运用了类型推导的来使Map和Set的创建语句缩短,程序员都应该是懒人吗!呵呵。
这里,对于类型推导,还有一个比较重要的用法,就是"泛型单例工厂"。举个例子如下:
假设有一个如下的接口:
这个接口可以对Number的子类进行封装,它提供了一个方法可以输出值的平方。对于这样的Wrapper,我并不想对于每一个T都实例化一个相应的对象,那样有一些浪费,这时,就可以使用这个泛型单例工厂来生成支持不同T的单例。另外,因为NumberWrapper的泛型信息在运行时是会被擦除的,所以也没有必要对每一个T生成一个实例。泛型单例工厂的代码如下:
这里,有一个点要注意下,就是getWrapperInstance()方法的的类型转换,这里是一个NumberWrapper<Number>向NumberWrapper<T>的转换,这里,由于square()方法返回的仅仅是平方,这里是不会导致类型错误的,所以可以放心的禁止这条警告了。
程序的运行结果如下所示:
4.0
0.0025000000000000005
说明程序还是运行良好的。
2. 递归类型限制
所谓递归类型限制,是使用包含某个参数类型本身的表达式去限制参数的类型。比如java.util.Collections的max()方法,定义如下:
这里面的具体实现先不用去关注。这里,类型参数的定义是T extends Object & Comparable<? super T>。T是要扩展自Comparable<? super T>的,这里就是一个递归类型限制。其实也好理解,比如String类就是Comparable<String>的子类,Integer是Comparable<Integer>的子类,只有类型是"可以比较的"才能去计算的最大值吗。
这个的用法不多,就不去仔细研究了,到真正会使用的时候再去研究也不晚,这就是所谓的"延迟加载"吧,呵呵。
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>的子类,只有类型是"可以比较的"才能去计算的最大值吗。
这个的用法不多,就不去仔细研究了,到真正会使用的时候再去研究也不晚,这就是所谓的"延迟加载"吧,呵呵。