泛型(Generics)是由编译器来验证从客户端将一种类型传送给某一对象的机制,实现了数据类型的参数化.
1.在使用泛型之前,先来看一下没有泛型的java集合框架(Collection)
import java.util.ArrayList;
import java.util.List;
public class GenericsDemo1 {
private final List list = new ArrayList();
public void addList() {
list.add("test");
list.add(10);
}
public void showList() {
for (Object o : list) {
System.out.println(((String) o));
}
}
public static void main(String[] args) {
GenericsDemo g = new GenericsDemo();
g.addList();
g.showList();
}
}
此段程序中包含两个方法,addList方法为list中增加了一个String类型和一个int类型;showList方法中,由于Collection在内部用的是Object,我们需要用String进行强制转换,运行时会出现ClassCastException.
在实际开发中,开发这必须用实际类型进行Cast,编译器无法检查,代码在运行时会有抛出ClassCastException的危险.
2.使用泛型
j2se在1.5为所有的Collection都加入了泛型的声明,例如:
public class ArrayList<E> extends AbstractList<E> {
public void add(E element) {
}
public Iterator<E> iterator() {
}
}
这里的E是一个类型变量,并没有对它进行具体类型的定义,只是一个类型占位符,由使用者指定类型.通过使用泛型可增加类型安全:
>>在类型没有变化时,Collection是类型安全的;
>>类型的匹配错误在编译期间就可以捕捉到;
>>内在的类型转换优于在外部的人工造型;
>>使接口更加强壮,因为它增加了类型;
使用泛型修改第1节中的程序:
import java.util.ArrayList;
import java.util.List;
public class GenericsDemo2 {
private final List<String> list = new ArrayList<String>();
public void addList() {
list.add("test");
// list.add(10);
}
public void showList() {
for (String o : list) {
System.out.println(o);
}
}
public static void main(String[] args) {
GenericsDemo g = new GenericsDemo();
g.addList();
g.showList();
}
}
注意,使用泛型后,list.add(10)类型匹配错误,无法通过编译.
3.类型通配符
通过泛型可以做到限制类型,那么能否利用'多态'的特性呢?
List<Object> list = new ArrayList<String>();
如上,定义了一个存储Object类型的List,利用'多态'的特性,创建了一个String类型的ArrayList赋给list.
实际上,这行代码是无法正常编译的,应该使用以下定义方式:
List<?> list3 = new ArrayList<String>();
其中?表示unknown类型,能与其他类型进行匹配,类似于'父类',称作类型通配符.有以下表现形式:
<E> >> E类型
<? extends E> >> 继承E的unknown类型
<? super E> >> E的unknown父类型
<?> >> unknown类型
下面通过一个例子来了解这几种通配符:
import java.util.ArrayList;
import java.util.List;
public class GenericsDemo3 {
public void a() {
List<Object> list = new ArrayList<>();
list.add(new Object());
list.add("a");
list.add(97);
list.add(null);
}
public void b() {
List<? extends Object> list = new ArrayList<String>();
// list.add(new Object());
// list.add("b");
// list.add(98);
list.add(null);
}
public void c() {
List<? super String> list = new ArrayList<>();
// list.add(new Object());
list.add("c");
// list.add(99);
list.add(null);
}
public void d() {
List<?> list = new ArrayList<>();
// list.add(new Object());
// list.add("d");
// list.add(100);
list.add(null);
}
}
此段程序包含的四个方法中,
在a方法中,泛型类型确定为Object,可成功添加四个元素;
在b方法中,list的定义是没问题的,但list.add("b")却无法通过编译,可知list内存储的数据类型的编译类型是unknown的,因此无法添加一个String.
在c方法中,定义了一个存储String的父类的list,但list.add(new Object())却无法通过编译,而list.addd("c")却能执行通过,由此可见此时<? super String>与<String>作用相同.
在d方法中,由于?是unknown类型,所以Object,String,Integer都是无法被添加的.
由于null是所有类的对象,所以上述四个方法中的list.add(null)都是可以成功执行的.
4.自定义泛型<T>
在编程过程中,通过<T>表示一个类型,具体类型由使用者提供,如:Map<K,V>{},推荐的命名:
K >> key,map的键
V >> value,list和set的内容,map的值
E >> 异常类
T >> 泛型
例:
public class GenericsDemo4 {
public static <T extends Comparable<T>> T max(T t1, T t2) {
if (t1.compareTo(t2) > 0) {
return t1;
}
return t2;
}
public static void main(String[] args) {
System.out.println(max(98, 97));
System.out.println(max("a", "b"));
// System.out.println(max(97, "b"));
}
}
此段程序在max方法中定义了一个泛型T,T实现了Comparable接口(不能用implements,只能用extends),Comparable比较的类型又是T,同时也将T作为参数和返回值.
在main方法中调用了3次max,只有前两次能够编译并执行,在第三次调用max(97,"b")时,传入的参数分别是Integer和String,编译器无法判断返回值的类型,无法完成编译.
执行后输出结果:
98
b
另外注意,定义的<T>可以同时继承类和实现接口,用&连接,上述的max方法也可如下定义:
public static <T extends Object & Comparable<T>> T max(T t1, T t2) {
if (t1.compareTo(t2) > 0) {
return t1;
}
return t2;
}
5.小结
泛型(Generics),实现类数据类型的参数化,通过使用泛型,对数据类型自动检查,避免了类型转换,增加了程序的安全性.