1.泛型的概念
在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高代码的重用率。
泛型是提供给javac 编译器使用的,可以限定集合的输入类型,让编译器挡住源代码程序中的非法输入,编译器编译带类型说明的集合时会擦除"类型"信息,使程序运行效率不受影响,对于参数化的泛型类型,getClass()方法的返回值和原始类型完全一样, 由于编译器生成的字节码会去掉泛型的类型信息,只要能跳过编译器,就可以往某个泛型集合加入其它类型的数据,例如,用反射得到集合,在调用其add方法就可.
2.为何JDK1.5引入泛型
JDK5以前,对象保存到集合中就会失去其特性,取出时通常要程序员手工进行类型的强制转换,这样不可避免就会引发程序的一些安全性问题。例如:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
package
com.itcast.generic;
import
java.util.ArrayList;
import
java.util.List;
import
java.util.Random;
public
class
GenericTest1 {
public
static
void
main(String[] args) {
List list =
new
ArrayList();
list.add(
new
Random());
list.add(
"abc"
);
//运行时会出错,但编码时发现不了---throw java.lang.ClassCastException
Integer num = (Integer) list.get(
0
);
}
}
|
而使用泛型之后:
1
|
编译器会在编译时报错,集合内只能存储java.lang.String类型的实例.
|
3.泛型的简单应用和了解泛型
1
|
JDK5中的泛形允许程序员在编写集合代码时,就限制集合的处理类型,从而把原来程序运行时可能发生问题,转变为编译时的问题,以此提高程序的可读性和稳定性(尤其在大型程序中更为突出)。
|
注意:泛型是提供给javac编译器使用的,它用于限定集合的输入类型,让编译器在源代码级别上,即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后,生成的class文件中将不再带有泛形信息,以此使程序运行效率不受到影响,这个过程称之为“擦除”。例如:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
package
com.itcast.generic;
import
java.util.ArrayList;
import
java.util.List;
public
class
GenericTest2 {
public
static
void
main(String[] args)
throws
Exception {
//List集合中放入java.lang.Integer类型变量
List<Integer> list =
new
ArrayList<Integer>();
list.add(
50
);
//通过字节码文件反射调用add方法加入java.lang.String类型变量
list.getClass().getMethod(
"add"
, Object.
class
).invoke(list,
"itcast"
);
System.out.println(list);
}
}
|
1
|
测试结果:
|
1
|
泛形的基本术语:以ArrayList<E>为例:<>念着typeof
|
1
2
3
4
5
|
•ArrayList<E>中的E称为类型参数变量.
•ArrayList<Integer>中的Integer称为实际类型参数 .
•整个称为ArrayList<E>泛型类型 .
•整个ArrayList<Integer>称为参数化的类型ParameterizedType.
•ArrayList称为原始类型.
|
使用泛型时需要注意的问题:
1.参数化类型与原始类型的兼容性:
a.参数化类型可以引用一个原始类型的对象,编译器报告警告,例如:
Collection<String> c = new Vector();
b.原始类型可以引用一个参数化类型的对象,编译器报告警告,例如:
Collection c = new Vector<String>();
2.参数化类型不考虑类型参数继承关系:
List<String> list = new ArrayList<Object>(); //error
List<Object> list = new ArrayList<String>(); //error
3.使用泛形时,泛形类型须为引用类型,不能是基本数据类型
4.在创建数组实例时,数组元素不能是参数化类型.
4.泛型的通配符扩展应用
4.1 通配符
1
|
问题:l定义一个方法,接收一个任意集合,并打印出集合中的所有元素,如下所示:
|
错误方式:
1
2
3
4
5
|
void
print (Collection<Object> c) {
for
(Object e : c) {
System.out.println(e);
}
}
|
正确方式:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package
com.itcast.generic;
import
java.util.ArrayList;
import
java.util.Collection;
public
class
GenericTest3 {
public
static
void
main(String[] args) {
Collection<String> c =
new
ArrayList<String>();
Collection<Integer> c1 =
new
ArrayList<Integer>();
printCollection(c);
printCollection(c1);
}
public
static
void
printCollection(Collection<?> c){
//c.add(1); 在方法体内不能调用与类型相关的方法,例如add()方法
c.size();
//查看API,size方法与类型不相关.
for
(Object obj:c){
System.out.println(obj);
}
}
}
|
1
2
|
l.此种形式下需要注意的是:由于print方法c参数的类型为Collection<?>,即表示一种不确定的类型,因此在方法体内不 能调用与类型相关的方法,例如add()方法。
2
.总结:使用?通配符主要用于引用对象,使用了?通配符,就只能调对象与类型无关的方法,不能调用对象与类型有关的方法
|
4.2 有限制的通配符
a.限定通配符的上边界:(?必须是Number的子类)
b.限定通配符的下边界 : (?必须是Integer的父类)
C.限定范围总是包括自己
5.泛型的通配符扩展应用案例
1
|
遍历一个Map集合:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package
com.itcast.generic;
import
java.util.HashMap;
import
java.util.Map;
/**
* 遍历Map集合
* @author Say
*
*/
public
class
IteratorMap {
public
static
void
main(String[] args) {
Map<String,Integer> map =
new
HashMap<String, Integer>();
map.put(
"itcast"
,
1
);
map.put(
"flx"
,
50
);
map.put(
"黑马"
,
41
);
for
(Map.Entry<String, Integer> entry:map.entrySet()){
System.out.println(entry.getKey()+
"-->"
+entry.getValue());
}
}
}
|
6.自定义泛型方法
1
|
Java中的泛型没有C++中模版强大的原因: Java中泛型在编译器中实现的,生成字节码的过程当中会擦除泛型。
|
泛型方法定义规则:
Java程序中的普通方法、构造方法和静态方法中都可以使用泛型。方法使用泛形前,必须对泛形进行声明,语法:<T>,T可以是任意字母,但通常必须要大写。<T>通常需放在方法的返回值声明之前。
例如:
public static <T> void doxx(T t);
泛型方法定义注意问题:
•只有对象类型才能作为泛型方法的实际参数。
•在泛型中可以同时有多个类型.
例如:
public static <K,V> V getValue(K key) { return map.get(key);}
public static <K extends Annotation> void getXX(){}
public static <K extends Annotation & Cloneable> void getXX(){}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
package
com.itcast.generic;
/**
* 编写一个泛形方法,实现数组元素的交换。
*/
public
class
SwapArray {
public
static
void
main(String[] args) {
//对于数组中的int类型不会自动装箱和拆箱
swap(
new
String[]{
"a"
,
"bncd"
,
"fdsafdsa"
},
2
,
0
);
swap(
new
Integer[]{
15
,
25
,
30
,
25
,
47
},
2
,
4
);
}
public
static
<T>
void
swap(T[] arr,
int
x,
int
y){
T temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
|
7.自定义泛型类
如果一个类多处都要用到同一个泛型,这时可以把泛形定义在类上(即类级别的泛型)
语法格式如下:
public class GenericDao<T> {
private T field1;
public void save(T obj){}
public T getId(int id){}
}
注意: 静态方法不能使用类定义的泛形,而应单独定义泛形。先使用类级别的泛型.
泛形的典型应用:BaseDao
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
package
com.itcast.generic;
import
java.util.Set;
public
class
GenericDao<T> {
public
void
add(T t){
}
public
T findById(
int
id){
return
null
;
}
public
void
delete(T t){
}
public
void
update(T t){
}
public
Set<T> findByConditions(String where){
return
null
;
}
}
|
8.通过反射获取泛型的实际类型参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
package
com.itcast.generic;
import
java.lang.reflect.Method;
import
java.lang.reflect.ParameterizedType;
import
java.lang.reflect.Type;
import
java.util.Date;
import
java.util.List;
/**
* 以泛型方法获取参数类型
*/
public
class
TypeArgumentsTest {
public
static
void
main(String[] args)
throws
Exception{
//获取applyList方法对象
Method method = TypeArgumentsTest.
class
.getMethod(
"applyList"
, List.
class
);
//获取方法上泛型参数
Type[] types=method.getGenericParameterTypes();
ParameterizedType pType = (ParameterizedType) types[
0
];
//获取原始类型
System.out.println(pType.getRawType());
//获取实际类型参数
System.out.println(pType.getActualTypeArguments()[
0
]);
}
public
static
void
applyList(List<Date> list){
}
}
|