Java范型浅析

下面我们来看看最后一个知识点，定义一个函数，该函数接受一个范型类作为参数。首先让我们来看一个最简单的情况，参数是一个实例化的范型类：    public static void test(ArrayList<Number> l) ...{
         l.add(new Integer(2));
     }
        上述代码中，形参list的元素被实例化为Number类型。在使用该函数的时候我们能不能传入一个元素为Integer的list呢？看看下面代码合法吗？     ArrayList<Integer> l = new ArrayList<Integer>();
     test(l);  //此处编译器会报错！！
        答案上面已经给出了：不行！对于这种形参，实参的类型必须和他完全一致，即也应该是一个元素为Number的list才可以，其他的实参一律不行。这是为什么呢？Integer不是Number的子类吗？子类的对象传递给父类的引用，不可以吗？这里我们就要注意了，Integer确实是Number的子类，但是，ArrayList<Integer>并不是ArrayList<Number>的子类，二者之间没有任何的继承关系！！因此这样传递参数是不允许的。如果允许的话，会出现什么问题吗？当然会，我们对test函数重新定义一下：    public static void test(ArrayList<Number> l) ...{
         l.add(new Float(2));
     }
        大家可以看到，在函数内部，我们把Float类型的元素插入到链表中。因为链表是Number类型，这条语句没问题。但是，如果实参是一个Integer类型的链表，他能存储Float类型的数据吗？？显然不能，这样就会造成运行时错误。于是，编译器干脆就不允许进行这样的传递。
        通过分析我们看到，出错的可能性只有一个：在向容器类添加内容的时候可能造成类型不匹配。那么有些人可能会有这种要求：“我保证一定不对容器添加内容，我非常希望能够将一个Integer类（Number类的子类）组成的链表传递进来”。Sun的那帮大牛们当然会考虑到这种诉求，这样的功能是可以实现的，并且还有两种方式呢，看下面代码：//      1.在定义方法的时候使用Wildcard（也就是下述代码中的问号）。
    public static void test1(ArrayList<? extends Number> l) ...{
         Integer n = new Integer(45);
         Number x = l.get(0); //从链表中取数据是允许的
         l.add(n);  //错误！！往链表里面插入数据是被编译器严格禁止的！！
     }

//      2.定义一个范型方法。代码如下：
    public static <T extends Number> void test2(ArrayList<T> l) ...{
         Number n = l.get(0);
         T d = l.get(0);
         l.add(d);  //与上面的方法相比，插入一个范型数据是被允许的，相对灵活一些
         l.add(n);  //错误！！只可以插入范型数据，绝不可插入具体类型数据。
     }
        按照上述代码的写法，只要我们对形参添加了一定的约束条件，那么我们在传递实参的时候，对实参的严格约束就会降低一些。上述代码都指定了一个类Number，并用了extends关键字，因此，在传递实参的时候，凡是从Number继承的类组成的链表，均可以传递进去。但上面代码的注释中也说的很清楚，为了不出现运行时错误，编译器会对你调用的方法做严格的限制：凡是参数为范型的方法，一律不需调用！！ l.get(0)是合法的，因为参数是整型而不是范型；l.add(x)就不合法，因为add函数的参数是范型。但是定义一个范型方法还是有一定灵活性的，如果传入的数据也是范型，编译器还是认可的，因为范型对范型，类型安全是可以保证的。
        从上述代码可以看出，定义一个范型方法要比Wildcard稍微灵活一些，可以往链表中添加T类型的对象，而Wildcard中是不允许往链表中添加任何类型的对象的。那么我们还要Wildcard干什么呢？Wildcard还是有他存在的意义的，那就是，Wildcard支持另外一个关键字super，而范型方法不支持super关键字。换句话说，如果你要实现这样的功能：“传入的参数应该是指定类的父类”，范型方法就无能为力了，只能依靠Wildcard来实现。代码如下：    public static void test5(ArrayList<? super Integer> l) ...{
         Integer n = new Integer(45);
         l.add(n);  //与上面使用extends关键字相反，往链表里面插入指定类型的数据是被允许的。
         Object x = l.get(0); //从链表里取出一个数据仍然是被允许的，不过要赋值给Object对象。
         l.add(x);   //错误！！将刚刚取出的数据再次插入链表是不被允许的。
     }        这种实现方式的特点我们前面已经说过了，就是对实参的限制更改为：必须是指定类型的父类。这里我们指定了Integer类，那么实参链表的元素类型，必须是Number类及其父类。下面我们重点讨论一下上述代码的第四条语句，为什么将刚刚取出的数据再次插入链表不被允许？？道理很简单，刚刚取出的数据被保存在一个Object类型的引用中，而链表的add方法只能接受指定类型Integer及其子类，类型不匹配当然不行。有些人可能立刻会说，我将他强制转化为Integer类（即l.add((Integer)x); ），编译器不就不报错了吗？确实，经过强制转化后，编译器确实没意见了。不过这种强制转化有可能带来运行时错误。因为你传入的实参，其元素类型是Integer的父类，比如是Number。那么，存储在该链表中的第一个数据，很有可能是Double或其他类型的，这是合法的。那么你取出的第一个元素x也会是Double类型。那么你把一个Double类型强制转化为Integer类型，显然是一个运行时错误。
        难道“把取出的元素再插入到链表中”这样一个功能就实现不了吗？当然可以，不过不能直接实现，要借助范型函数的帮忙，因为在范型函数中，刚刚取出的元素再存回去是不成问题的。定义这样一个范型函数，我们称之为帮助函数。代码如下：    //帮助函数
    public static <T>void helperTest5(ArrayList<T> l, int index) ...{
         T temp = l.get(index);
         l.add(temp);
     }
    
    //主功能函数
    public static void test5(ArrayList<? super Integer> l) ...{
         Integer n = new Integer(45);
         l.add(n);  
         helperTest5(l, 0);   //通过帮助类，将指定的元素取出后再插回去。
     }
        上述两个函数结合的原理就是：利用Wildcard的super关键字来限制参数的类型（范型函数不支持super，要是支持的话就不用这么麻烦了），然后通过范型函数来完成取出数据的再存储。
        以上就是我学习范型的所有心得。下面再把《Java核心编程》中列出的使用范型时的注意事项列出来（各种操作被禁止的原因就不具体说明了），供大家参考：//1、不可以用一个本地类型（如int    float）来替换范型
//2、运行时类型检查，不同类型的范型类是等价的（Pair<String>与Pair<Employee>是属于同一个类型Pair），
//     这一点要特别注意，即如果a instanceof Pair<String>==true的话，并不代表a.getFirst()的返回值是一个String类型
//3、范型类不可以继承Exception类，即范型类不可以作为异常被抛出
//4、不可以定义范型数组
//5、不可以用范型构造对象，即first = new T(); 是错误的
//6、在static方法中不可以使用范型，范型变量也不可以用static关键字来修饰
//7、不要在范型类中定义equals(T x)这类方法，因为Object类中也有equals方法，当范型类被擦除后，这两个方法会冲突
//8、根据同一个范型类衍生出来的多个类之间没有任何关系，不可以互相赋值
//     即Pair<Number> p1;   Pair<Integer> p2;    p1=p2;   这种赋值是错误的。
//9、若某个范型类还有同名的非范型类，不要混合使用，坚持使用范型类
//     Pair<Manager> managerBuddies = new Pair<Manager>(ceo, cfo);
//     Pair rawBuddies = managerBuddies;   这里编译器不会报错，但存在着严重的运行时错误隐患