什么是泛型

廖雪峰

资深软件开发工程师，业余马拉松选手。

在讲解什么是泛型之前，我们先观察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，代码如下：

public class ArrayList {

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 strList = new ArrayList();

// 创建可以存储Float的ArrayList:

ArrayList floatList = new ArrayList();

// 创建可以存储Person的ArrayList:

ArrayList personList = new ArrayList();

因此，泛型就是定义一种模板，例如ArrayList，然后在代码中为用到的类创建对应的ArrayList<类型>：

ArrayList strList = new ArrayList();

由编译器针对类型作检查：

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实现了List接口，它可以向上转型为List：

public class ArrayList implements List {

...

}

List list = new ArrayList();

即类型ArrayList可以向上转型为List。

要特别注意：不能把ArrayList向上转型为ArrayList或List。

这是为什么呢？假设ArrayList可以向上转型为ArrayList，观察一下代码：

// 创建ArrayList类型：

ArrayList integerList = new ArrayList();

// 添加一个Integer：

integerList.add(new Integer(123));

// “向上转型”为ArrayList：

ArrayList numberList = integerList;

// 添加一个Float，因为Float也是Number：

numberList.add(new Float(12.34));

// 从ArrayList获取索引为1的元素（即添加的Float）：

Integer n = integerList.get(1); // ClassCastException!

我们把一个ArrayList转型为ArrayList类型后，这个ArrayList就可以接受Float类型，因为Float是Number的子类。但是，ArrayList实际上和ArrayList是同一个对象，也就是ArrayList类型，它不可能接受Float类型，

所以在获取Integer的时候将产生ClassCastException。

实际上，编译器为了避免这种错误，根本就不允许把ArrayList转型为ArrayList。

特别注意

ArrayList和ArrayList两者完全没有继承关系。

用一个图来表示泛型的继承关系，就是T不变时，可以向上转型，T本身不能向上转型：

List ArrayList

▲ ▲

│ │

│ X

│ │

ArrayList ArrayList

小结

泛型就是编写模板代码来适应任意类型；

泛型的好处是使用时不必对类型进行强制转换，它通过编译器对类型进行检查；

注意泛型的继承关系：可以把ArrayList向上转型为List（T不能变！），但不能把ArrayList向上转型为ArrayList（T不能变成父类）。