共计 3137 个字符,预计需要花费 8 分钟才能阅读完成。
在讲解什么是泛型之前,我们先观察 Java 标准库提供的ArrayList
,它可以看作“可变长度”的数组,因为用起来比数组更方便。
实际上 ArrayList
内部就是一个 Object[]
数组,配合存储一个当前分配的长度,就可以充当“可变数组”:
public class ArrayList {private Object[] array;
private int size;
public void add(Object e) {...}
public void remove(int index) {...}
public Object get(int index) {...}
}
如果用上述 ArrayList
存储 String
类型,会有这么几个缺点:
- 需要强制转型;
- 不方便,易出错。
例如,代码必须这么写:
ArrayList list = new ArrayList();
list.add("Hello");
// 获取到 Object,必须强制转型为 String:
String first = (String) list.get(0);
很容易出现 ClassCastException,因为容易“误转型”:
list.add(new Integer(123));
// ERROR: ClassCastException:
String second = (String) list.get(1);
要解决上述问题,我们可以为 String
单独编写一种ArrayList
:
public class StringArrayList {private String[] array;
private int size;
public void add(String e) {...}
public void remove(int index) {...}
public String get(int index) {...}
}
这样一来,存入的必须是String
,取出的也一定是String
,不需要强制转型,因为编译器会强制检查放入的类型:
StringArrayList list = new StringArrayList();
list.add("Hello");
String first = list.get(0);
// 编译错误: 不允许放入非 String 类型:
list.add(new Integer(123));
问题暂时解决。
然而,新的问题是,如果要存储 Integer
,还需要为Integer
单独编写一种ArrayList
:
public class IntegerArrayList {private Integer[] array;
private int size;
public void add(Integer e) {...}
public void remove(int index) {...}
public Integer get(int index) {...}
}
实际上,还需要为其他所有 class 单独编写一种ArrayList
:
- LongArrayList
- DoubleArrayList
- PersonArrayList
- …
这是不可能的,JDK 的 class 就有上千个,而且它还不知道其他人编写的 class。
为了解决新的问题,我们必须把 ArrayList
变成一种模板:ArrayList<T>
,代码如下:
public class ArrayList<T> {private T[] array;
private int size;
public void add(T e) {...}
public void remove(int index) {...}
public T get(int index) {...}
}
T
可以是任何 class。这样一来,我们就实现了:编写一次模版,可以创建任意类型的ArrayList
:
// 创建可以存储 String 的 ArrayList:
ArrayList<String> strList = new ArrayList<String>();
// 创建可以存储 Float 的 ArrayList:
ArrayList<Float> floatList = new ArrayList<Float>();
// 创建可以存储 Person 的 ArrayList:
ArrayList<Person> personList = new ArrayList<Person>();
因此,泛型就是定义一种模板,例如ArrayList<T>
,然后在代码中为用到的类创建对应的ArrayList< 类型 >
:
ArrayList<String> strList = new ArrayList<String>();
由编译器针对类型作检查:
strList.add("hello"); // OK
String s = strList.get(0); // OK
strList.add(new Integer(123)); // compile error!
Integer n = strList.get(0); // compile error!
这样一来,既实现了编写一次,万能匹配,又通过编译器保证了类型安全:这就是泛型。
向上转型
在 Java 标准库中的 ArrayList<T>
实现了 List<T>
接口,它可以向上转型为List<T>
:
public class ArrayList<T> implements List<T> {...}
List<String> list = new ArrayList<String>();
即类型 ArrayList<T>
可以向上转型为List<T>
。
要 特别注意 :不能把ArrayList<Integer>
向上转型为 ArrayList<Number>
或List<Number>
。
这是为什么呢?假设 ArrayList<Integer>
可以向上转型为ArrayList<Number>
,观察一下代码:
// 创建 ArrayList<Integer> 类型:
ArrayList<Integer> integerList = new ArrayList<Integer>();
// 添加一个 Integer:
integerList.add(new Integer(123));
//“向上转型”为 ArrayList<Number>:
ArrayList<Number> numberList = integerList;
// 添加一个 Float,因为 Float 也是 Number:
numberList.add(new Float(12.34));
// 从 ArrayList<Integer> 获取索引为 1 的元素(即添加的 Float):
Integer n = integerList.get(1); // ClassCastException!
我们把一个 ArrayList<Integer>
转型为 ArrayList<Number>
类型后,这个 ArrayList<Number>
就可以接受 Float
类型,因为 Float
是Number
的子类。但是,ArrayList<Number>
实际上和 ArrayList<Integer>
是同一个对象,也就是 ArrayList<Integer>
类型,它不可能接受 Float
类型,
所以在获取 Integer
的时候将产生ClassCastException
。
实际上,编译器为了避免这种错误,根本就不允许把 ArrayList<Integer>
转型为ArrayList<Number>
。
特别注意
ArrayList<Integer> 和 ArrayList<Number> 两者完全没有继承关系。
小结
泛型就是编写模板代码来适应任意类型;
泛型的好处是使用时不必对类型进行强制转换,它通过编译器对类型进行检查;
注意泛型的继承关系:可以把 ArrayList<Integer>
向上转型为 List<Integer>
(T
不能变!),但不能把 ArrayList<Integer>
向上转型为 ArrayList<Number>
(T
不能变成父类)。