从jdk1.5开始,Java中开始支持范型了。范型是一个很有用的编程工具,给我们带来了极大的灵活性。在看了《java核心编程》之后,我小有收获,写出来与大家分享。
所谓范型,我的感觉就是,不用考虑对象的具体类型,就可以对对象进行一定的操作,对任何对象都能进行同样的操作。这就是灵活性之所在。但是,正是因为没有考虑对象的具体类型,因此一般情况下不可以使用对象自带的接口函数,因为不同的对象所携带的接口函数不一样,你使用了对象A的接口函数,万一别人将一个对象B传给范型,那么程序就会出现错误,这就是范型的局限性。所以说,范型的最佳用途,就是用于实现容器类,实现一个通用的容器。该容器可以存储对象,也可以取出对象,而不用考虑对象的具体类型。因此,在学习范型的时候,一定要了解这一点,你不能指望范型是万能的,要充分考虑到范型的局限性。下面我们来探讨一下范型的原理以及高级应用。首先给出一个范型类:
public class Pair<T>
{
public Pair() { first = null; second = null; }
public Pair(T first, T second) { this.first = first; this.second = second; }
public T getFirst() { return first; }
public T getSecond() { return second; }
public void setFirst(T newValue) { first = newValue; }
public void setSecond(T newValue) { second = newValue; }
private T first;
private T second;
}
我们看到,上述Pair类是一个容器类(我会多次强调,范型天生就是为了容器类的方便实现),容纳了2个数据,但这2个数据类型是不确定的,用范型T来表示。关于范型类如何使用,那是最基本的内容,在此就不讨论了。
下面我们来讨论一下Java中范型类的实现原理。在java中,范型是在编译器中实现的,而不是在虚拟机中实现的,虚拟机对范型一无所知。因此,编译器一定要把范型类修改为普通类,才能够在虚拟机中执行。在java中,这种技术称之为“擦除”,也就是用Object类型替换范型。上述代码经过擦除后就变成如下形式:
public class Pair
{
public Pair(Object first, Object second)
{
this.first = first;
this.second = second;
}
public Object getFirst() { return first; }
public Object getSecond() { return second; }
public void setFirst(Object newValue) { first = newValue; }
public void setSecond(Object newValue) { second = newValue; }
private Object first;
private Object second;
}
大家可以看到,这是一个普通类,所有的范型都被替换为Object类型,他被称之为原生类。每当你用一个具体类去实例化该范型时,编译器都会在原生类的基础上,通过强制约束和在需要的地方添加强制转换代码来满足需求,但是不会生成更多的具体的类(这一点和c++完全不同)。我们来举例说明这一点:
Pair<Employee> buddies = new Pair<Employee>();
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
//在上述原生代码中,此处参数类型是Object,理论上可以接纳各种类型,但编译器通过强制约束
//你只能在此使用Employee(及子类)类型的参数,其他类型编译器一律报错
buddies.setFirst(new Employee("张三"));
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
//在上述原生代码中,getFirst()的返回值是一个Object类型,是不可以直接赋给类型为Employee的buddy的
//但编译器在此做了手脚,添加了强制转化代码,实际代码应该是Employee buddy = (Employee)buddies.getFirst();
//这样就合法了。但编译器做过手脚的代码你是看不到的,他是以字节码的形式完成的。
Employee buddy = buddies.getFirst();
下面我们再来考察一个更复杂的情况,如果我们的Pair类要保证第二个属性一定要大于第一个属性,该如何做?这就涉及到两个属性的比较,但是这2个属性类型未知,可以比较吗?我们前面也讲过,一般情况下不要涉及类型的具体信息。但是现在要比较2个属性,不得不涉及类型的具体信息了。Java还是考虑到了这一点,那就是,范型类可以继承自某一个父类,或者实现某个接口,或者同时继承父类并且实现接口。这样的话,就可以对类型调用父类或接口中定义的方法了。代码如下:
public class Pair<T extends Comparable>
{
public boolean setSecond(T newValue) {
boolean flag = false;
If(newValue.compareTo(first)>0) {
second = newValue;
flag = true;
}
return flag;
}
private T first;
private T second;
}
我们看到,上面的范型T被我们添加了一个约束条件,那就是他必须实现Comparable接口,这样的话,我们就可以对范型T使用接口中定义的方法了,也就可以实现2个元素大小的比较。有人可能要问了,实现一个接口不是用implements吗?上面怎么用extends呢??为了简化范型的设计,无论是继承类还是实现接口,一律使用extends关键字。这是规定,没办法,记住就行了。若同时添加多个约束,各个约束之间用“&”分隔,比如:public class Pair<T extends Comparable & Serializable>。那么编译器是如何处理这种情况呢?前面讲过,范型类最终都会被转化为原生类。在前面没有添加约束的时候,编译器将范型通通替换为Object;而增加了约束之后,通通用第一个约束来替换范型(上面的代码就会用 Comparable来替换所有范型 ),当需要用到其他约束中定义的方法的时候,通过插入强制转化代码来实现。在此就不给出具体的例子了。
下面我们来看看最后一个知识点,定义一个函数,该函数接受一个范型类作为参数。首先让我们来看一个最简单的情况,参数是一个实例化的范型类:
public static void test(ArrayList<Number> l) {
l.add(new Integer(2));
}
上述代码中,形参list的元素被实例化为Number类型。在使用该函数的时候我们能不能传入一个元素为Integer的list呢?看看下面代码合法吗?
答案上面已经给出了:不行!对于这种形参,实参的类型必须和他完全一致,即也应该是一个元素为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); //错误!!往链表里面插入数据是被编译器严格禁止的!!
}
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
// 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继承的类组成的链表,均可以传递进去。但上面代码的注释中也说的很清楚,为了不出现运行时错误,编译器会对你调用的方法做严格的限制:凡是参数为范型的方法,一律不需调用!!
ArrayList<Integer> l = new ArrayList<Integer>();
test(l); //此处编译器会报错!!
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; 这里编译器不会报错,但存在着严重的运行时错误隐患
所谓范型,我的感觉就是,不用考虑对象的具体类型,就可以对对象进行一定的操作,对任何对象都能进行同样的操作。这就是灵活性之所在。但是,正是因为没有考虑对象的具体类型,因此一般情况下不可以使用对象自带的接口函数,因为不同的对象所携带的接口函数不一样,你使用了对象A的接口函数,万一别人将一个对象B传给范型,那么程序就会出现错误,这就是范型的局限性。所以说,范型的最佳用途,就是用于实现容器类,实现一个通用的容器。该容器可以存储对象,也可以取出对象,而不用考虑对象的具体类型。因此,在学习范型的时候,一定要了解这一点,你不能指望范型是万能的,要充分考虑到范型的局限性。下面我们来探讨一下范型的原理以及高级应用。首先给出一个范型类:
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/a41954a27d6ad96fa2c2cf816e677448.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/37c8bf68cdc3cc81759c34160776bc53.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/37c8bf68cdc3cc81759c34160776bc53.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/37c8bf68cdc3cc81759c34160776bc53.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/37c8bf68cdc3cc81759c34160776bc53.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/37c8bf68cdc3cc81759c34160776bc53.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/37c8bf68cdc3cc81759c34160776bc53.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/0196c3df5ea9e936f21e9932cca91014.gif)
我们看到,上述Pair类是一个容器类(我会多次强调,范型天生就是为了容器类的方便实现),容纳了2个数据,但这2个数据类型是不确定的,用范型T来表示。关于范型类如何使用,那是最基本的内容,在此就不讨论了。
下面我们来讨论一下Java中范型类的实现原理。在java中,范型是在编译器中实现的,而不是在虚拟机中实现的,虚拟机对范型一无所知。因此,编译器一定要把范型类修改为普通类,才能够在虚拟机中执行。在java中,这种技术称之为“擦除”,也就是用Object类型替换范型。上述代码经过擦除后就变成如下形式:
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/a41954a27d6ad96fa2c2cf816e677448.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/37c8bf68cdc3cc81759c34160776bc53.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/717446ca04a6125dc5b6b54e0fa14ab4.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/37c8bf68cdc3cc81759c34160776bc53.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/37c8bf68cdc3cc81759c34160776bc53.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/37c8bf68cdc3cc81759c34160776bc53.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/37c8bf68cdc3cc81759c34160776bc53.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/0196c3df5ea9e936f21e9932cca91014.gif)
大家可以看到,这是一个普通类,所有的范型都被替换为Object类型,他被称之为原生类。每当你用一个具体类去实例化该范型时,编译器都会在原生类的基础上,通过强制约束和在需要的地方添加强制转换代码来满足需求,但是不会生成更多的具体的类(这一点和c++完全不同)。我们来举例说明这一点:
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
下面我们再来考察一个更复杂的情况,如果我们的Pair类要保证第二个属性一定要大于第一个属性,该如何做?这就涉及到两个属性的比较,但是这2个属性类型未知,可以比较吗?我们前面也讲过,一般情况下不要涉及类型的具体信息。但是现在要比较2个属性,不得不涉及类型的具体信息了。Java还是考虑到了这一点,那就是,范型类可以继承自某一个父类,或者实现某个接口,或者同时继承父类并且实现接口。这样的话,就可以对类型调用父类或接口中定义的方法了。代码如下:
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/a41954a27d6ad96fa2c2cf816e677448.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/37c8bf68cdc3cc81759c34160776bc53.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/37c8bf68cdc3cc81759c34160776bc53.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/717446ca04a6125dc5b6b54e0fa14ab4.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/717446ca04a6125dc5b6b54e0fa14ab4.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/0196c3df5ea9e936f21e9932cca91014.gif)
我们看到,上面的范型T被我们添加了一个约束条件,那就是他必须实现Comparable接口,这样的话,我们就可以对范型T使用接口中定义的方法了,也就可以实现2个元素大小的比较。有人可能要问了,实现一个接口不是用implements吗?上面怎么用extends呢??为了简化范型的设计,无论是继承类还是实现接口,一律使用extends关键字。这是规定,没办法,记住就行了。若同时添加多个约束,各个约束之间用“&”分隔,比如:public class Pair<T extends Comparable & Serializable>。那么编译器是如何处理这种情况呢?前面讲过,范型类最终都会被转化为原生类。在前面没有添加约束的时候,编译器将范型通通替换为Object;而增加了约束之后,通通用第一个约束来替换范型(上面的代码就会用 Comparable来替换所有范型 ),当需要用到其他约束中定义的方法的时候,通过插入强制转化代码来实现。在此就不给出具体的例子了。
下面我们来看看最后一个知识点,定义一个函数,该函数接受一个范型类作为参数。首先让我们来看一个最简单的情况,参数是一个实例化的范型类:
![](https://i-blog.csdnimg.cn/blog_migrate/a41954a27d6ad96fa2c2cf816e677448.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/0196c3df5ea9e936f21e9932cca91014.gif)
上述代码中,形参list的元素被实例化为Number类型。在使用该函数的时候我们能不能传入一个元素为Integer的list呢?看看下面代码合法吗?
答案上面已经给出了:不行!对于这种形参,实参的类型必须和他完全一致,即也应该是一个元素为Number的list才可以,其他的实参一律不行。这是为什么呢?Integer不是Number的子类吗?子类的对象传递给父类的引用,不可以吗?这里我们就要注意了,Integer确实是Number的子类,但是,ArrayList<Integer>并不是ArrayList<Number>的子类,二者之间没有任何的继承关系!!因此这样传递参数是不允许的。如果允许的话,会出现什么问题吗?当然会,我们对test函数重新定义一下:
![](https://i-blog.csdnimg.cn/blog_migrate/a41954a27d6ad96fa2c2cf816e677448.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/0196c3df5ea9e936f21e9932cca91014.gif)
大家可以看到,在函数内部,我们把Float类型的元素插入到链表中。因为链表是Number类型,这条语句没问题。但是,如果实参是一个Integer类型的链表,他能存储Float类型的数据吗??显然不能,这样就会造成运行时错误。于是,编译器干脆就不允许进行这样的传递。
通过分析我们看到,出错的可能性只有一个:在向容器类添加内容的时候可能造成类型不匹配。那么有些人可能会有这种要求:“我保证一定不对容器添加内容,我非常希望能够将一个Integer类(Number类的子类)组成的链表传递进来”。Sun的那帮大牛们当然会考虑到这种诉求,这样的功能是可以实现的,并且还有两种方式呢,看下面代码:
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/a41954a27d6ad96fa2c2cf816e677448.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/0196c3df5ea9e936f21e9932cca91014.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/a41954a27d6ad96fa2c2cf816e677448.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/0196c3df5ea9e936f21e9932cca91014.gif)
按照上述代码的写法,只要我们对形参添加了一定的约束条件,那么我们在传递实参的时候,对实参的严格约束就会降低一些。上述代码都指定了一个类Number,并用了extends关键字,因此,在传递实参的时候,凡是从Number继承的类组成的链表,均可以传递进去。但上面代码的注释中也说的很清楚,为了不出现运行时错误,编译器会对你调用的方法做严格的限制:凡是参数为范型的方法,一律不需调用!!
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
从上述代码可以看出,定义一个范型方法要比Wildcard稍微灵活一些,可以往链表中添加T类型的对象,而Wildcard中是不允许往链表中添加任何类型的对象的。那么我们还要Wildcard干什么呢? Wildcard还是有他存在的意义的,那就是, Wildcard支持另外一个关键字super,而范型方法不支持super关键字。换句话说,如果你要实现这样的功能:“传入的参数应该是指定类的父类”,范型方法就无能为力了,只能依靠Wildcard来实现。代码如下:
![](https://i-blog.csdnimg.cn/blog_migrate/a41954a27d6ad96fa2c2cf816e677448.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/0196c3df5ea9e936f21e9932cca91014.gif)
难道“把取出的元素再插入到链表中”这样一个功能就实现不了吗?当然可以,不过不能直接实现,要借助范型函数的帮忙,因为在范型函数中,刚刚取出的元素再存回去是不成问题的。定义这样一个范型函数,我们称之为帮助函数。代码如下:
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/a41954a27d6ad96fa2c2cf816e677448.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/0196c3df5ea9e936f21e9932cca91014.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/a41954a27d6ad96fa2c2cf816e677448.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/0196c3df5ea9e936f21e9932cca91014.gif)
上述两个函数结合的原理就是:利用Wildcard的super关键字来限制参数的类型(范型函数不支持super,要是支持的话就不用这么麻烦了),然后通过范型函数来完成取出数据的再存储。
以上就是我学习范型的所有心得。下面再把《Java核心编程》中列出的使用范型时的注意事项列出来(各种操作被禁止的原因就不具体说明了),供大家参考:
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)