面向对象的一个重要目标是对代码重用的支持。支持这个目标的一个重要的机制就是泛型机制(generic mechanism):例如:可以编写一个方法,将由一些对象组成的数组排序,方法的逻辑关系与被排序的对象的类型无关,此时可以使用泛型方法。
1. 使用Object模拟表示泛型
public static void main(String[] args) {
Integer[] ints = {1,4,7,3,2};
String[] strings = {"-a-","-c-","-ss-","-ds-","-e-"};
sort(ints);
sort(strings);
}
public static void sort(Object[] arr){
Arrays.stream(arr).forEach(x -> System.out.print(x));
Arrays.sort(arr);
System.out.printf("\n");
Arrays.stream(arr).forEach(x -> System.out.print(x));
}
缺陷
不能使用基本类型的,(可以使用包装类)。
只能使用Object类中的方法,局限性非常大。
补充
数组是协变性的。例如Employ和Student都是Person。
Person[] arr = new Employ[5];
arr[0] = new Student();
编译通过,但是运行时,抛出ClassCastException异常,因为Student is not a Employ。java中数组是类型兼容的,这叫做协变数组类型,但是集合Collection不是协变的。
2.简单的泛型类
//类的声明包含一个或多个参数,放在类名后的尖括号。
public class Generic <T>{
private T anyType;
public void write(T anyType){
this.anyType = anyType;
}
public T read(){
return anyType;
}
}
3.带有限制的通配符。
Circle 继承了Shape
public static void main(String[] args) {
List<Shape> shapes = new ArrayList<>();
List<Circle> circles = new ArrayList<>();
printTotalArea(shapes);
//printTotalArea(circles);
}
//计算总面积
public static void printTotalArea(Collection<Shape> collection){
double sum = 0;
for (Shape shape : collection) {
sum = + shape.area();
}
System.out.println(sum);
}
因为Collections不是协变的,必须传入Collection中的Shape类型,所以当传入circles会报错。
java5中的通配符可以弥补这个不足。
Collection
4.类型限界
写一个找最大对象的方法
public static <T> T findMax(T[] arr){
int maxIndex = 0;
for (int i = 1; i < arr.length; i++) {
if(arr[i].compareTo(arr[maxIndex])>0){
maxIndex = i;
}
}
return arr[maxIndex];
}
因为传入的类型不一定实现Comparable接口,所以arr[i].compareTo(arr[maxIndex])
会报错,只有当T is a Comparable的情况下才能正常调用。就可以使用类型限界来解决。
改下如下:
public static <T extends Comparable>
但是更好的做法是
//进一步限制比较的类型
public static <T extends Comparable<T>>
但是这样做仍然有问题,
假设有Shape类,实现了Comparable,Circle类继承了Shape;这时候Circle is a Comparable,但是Circle is not a Comparable;解决这个问题只要使用通配符就可以了。改写如下:
public static <T extends Comparable<? super T>>
看着有点乱,幸运的是,这基本是这种用语最复杂的用语了。
5.类型擦除
首先推荐一篇博客类型擦除,说的很好。
Java的泛型是伪泛型,code的过程泛型信息是存在的,对我们写的代码进行检查,而在编译之后,所有的泛型信息会被擦除掉(反编译还是存在的,但是运行就不存在了)。
一个简单的示例
public static void main(String[] args) {
ArrayList<String> arrayList1=new ArrayList<String>();
arrayList1.add("abc");
ArrayList<Integer> arrayList2=new ArrayList<Integer>();
arrayList2.add(123);
System.out.println(arrayList1.getClass()==arrayList2.getClass());
}
//true
在这个例子中,我们定义了两个ArrayList数组,不过一个是ArrayList泛型类型,只能存储字符串。一个是ArrayList泛型类型,只能存储整形。最后,我们通过arrayList1对象和arrayList2对象的getClass方法获取它们的类的信息,最后发现结果为true。说明泛型类型String和Integer都被擦除掉了,只剩下了原始类型。
原始类型(raw type)就是擦除去了泛型信息,最后在字节码中的类型变量的真正类型。无论何时定义一个泛型类型,相应的原始类型都会被自动地提供。类型变量被擦除(crased),并使用其限定类型(无限定的变量用Object)替换。
class Pair<T> {
private T value;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}
//原始类型
class Pair {
private Object value;
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
}
如果类型变量有限定,那么原始类型就用第一个边界的类型变量来替换。
比如Pair这样声明
public class Pair<T extends Comparable& Serializable>
那么原始类型就是Comparable
如果Pair这样声明
public class Pair<T extends Serializable&Comparable>
,那么原始类型就用Serializable替换如果使用一个泛型类而不带类型参数,那么使用的就是原始类。
限制
- 不能使用基本类型
- instanceOf检测,因为被擦出了,所以同一个泛型类都是true;
- static 方法和static域不可引用类的类型变量;(都被擦除了还怎么引用)
- 不能创建泛型数组
T[] arr = new T[10]
T将由他的限界代替,可能是Object或者是抽象类什么的。
5. 参数化类型的数组
public static void main(String[] args) {
//写这句话ide就提示错误,Generic array creation
AreaTest<String> [] arr1 = new AreaTest<String>[10];
AreaTest<Double> area = new AreaTest<Double>());
Object[] objects = arr1;
objects[0] = area;
String s = arr1[0].read();
}
类型擦除之后,都是AreaTest,所以是可以添加的,但是arr1[0].read()的时候产生一个ClassCastException,这是泛型应该避免的情况。