什么是泛型

263次阅读

共计 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。