这部分主要是结合 Java 虚拟机实现泛型的原理进一步研究如何更好的使用泛型。
8.5 泛型代码和虚拟机
虚拟机没有泛型类型对象---所有对象都属于普通类。所以编译器在编译的时候会进行类型擦除操作。
8.5.1 类型擦除
1. 什么是类型擦除？
无论何时定义一个泛型类型， 都自动提供了一个相应的原始类型 （ raw type )。原始类型的名字就是删去类型参数后的泛型类型名。擦除（ erased) 类型变量, 并替换为限定类型（无限定的变量用 Object。)
擦除规则：原始类型用第一个限定的类型变量来替换， 如果没有给定限定就用 Object 替换。
例如 Pair<T> 的原始类型如下：
public class Pair
{
private Object first;
private Object second;
public Pair(Object first, Object second)
{
this,first = first;
this.second = second;
}
public Object getFirstO { return first; }
public Object getSecondO { return second; }
public void setFirst(Object newValue) { first = newValue; }
public void setSecond(Object newValue) { second = newValue; }
}
// 因为 T 是无限定的变量，所以用 Object 代替结果是一个普通的类， 就好像泛型引人 Java 语言之前已经实现的那样。
多个限定类型例子：
// 泛型类【多个限定修饰符 Comparable 和 Serializable】
public class Interval <T extends Comparable & Serializable〉implements Serializable
{
private T lower;
private T upper;
public Interval (T first, T second)
{
if (first.compareTo(second) <= 0) { lower = first; upper = second; }
else { lower = second; upper = first; }
}
}
// 类型擦除后【多个限定符，选择第一个限定符 Comparable 】
public class Interval implements Serializable
{
private Comparable lower;
private Comparable upper;
public Interval (Coiparable first, Coiparable second) { . . . }
}注释：读者可能想要知道切换限定： class Interval<T extends Serializable & Comparable>会发生什么。如果这样做， 原始类型用 Serializable 替换 T, 而编译器在必要时要向Comparable 插入强制类型转换。为了提高效率，应该将标签（tagging) 接口（即没有方法的接口）放在边界列表的末尾。
8.5.2 翻译泛型表达式
当程序调用泛型方法时，如果擦除返回类型， 编译器插入强制类型转换。例如，下面这个语句序列
Pair<Employee> buddies = ...;
Employee buddy = buddies.getFirst();擦除 getFirst 的返回类型后将返回 Object 类型。编译器自动插人 Employee 的强制类型转换。
也就是说，编译器把这个方法调用翻译为两条虚拟机指令：
- 对原始方法 Pair.getFirst 的调用。
- 将返回的 Object 类型强制转换为 Employee 类型。
8.5.3 翻译泛型方法
类型擦除也会出现在泛型方法中。程序员通常认为下述的泛型方法
public static <T extends Comparable〉T min(T[] a)是一个完整的方法族，而擦除类型之后，只剩下一个方法：
// 擦除泛型之后
public static Comparable min(Comparable[] a)注意，类型参数 T 已经被擦除了， 只留下了限定类型 Comparable。
方法的擦除带来了两个复杂问题。看一看下面这个示例：
class DateInterval extends Pair<LocalDate>{
public void setSecond(LocalDate second){
if(second.compareTo( getFirst() ) >= 0){
super.setSecond(second);
}
}
}上面代码的意思是，一个日期区间是一对 LocalDate 对象，并且需要覆盖这个方法来确保第二个值永远不小于第一个值。这个类擦除后变成：
class DataInterval extends Pair // after erasure
{
public void setSecond(LocalDate second){...}
}令人感到奇怪的是，存在另一个从 Pair 继承的 setSecond 方法，即
// Pair 中存在的 setSecond 方法
public void setSecond(Object second)这显然是一个不同的方法，因为它有一个不同类型的参数 Object, 而不是 LocalDate。然而，不应该不一样。考虑下面的语句序列：
Datelnterval interval = new Datelnterval(. . .);
Pair<Loca1Date> pair = interval; // OK assignment to superclass
pair.setSecond(aDate);这里， 希望对 setSecond 的调用具有多态性， 并调用最合适的那个方法。由于 pair 引用 Datelnterval 对象，所以应该调用 Datelnterval.setSecond。问题在于类型擦除与多态发生了冲突。要解决这个问题， 就需要编译器在 Datelnterval 类中生成一个桥方法（bridge method)：
// 编译器重写了 Pair 的 setSecond(Object second)
@Override
public void setSecond(Object second) {
setSecond( (LocalDate) second ); // 调用擦除后的 setSecond( (LocalDate) second)【桥方法】
}要想了解它的工作过程，请仔细地跟踪下列语句的执行：
pair.setSecond(aDate);变量 pair 已经声明为类型 Pair<LocalDate>, 并且这个类型只有一个简单的方法叫 setSecond， 即 setSecond(Object second) 虚拟机用 pair 引用的对象调用这个方法。这个对象是 Datelnterval 类型的， 因而将会调用 Datelnterval.setSecond(Object)方法。这个方法是合成的
桥方法。它调用 Datelnterval.setSecond(LocalDate)， 这正是我们所期望的操作效果。
桥方法可能会变得十分奇怪。假设 Datelnterval 方法也覆盖了 getSecond 方法：
class Datelnterval extends Pair<LocalDate>
{
public LocalDate getSecond() {
return (Date) super.getSecond().clone();
}
}
// 在 Datelnterval 类中，有两个 getSecond 方法：
LocalDate getSecond() // defined in Datelnterval
Object getSecond() // overrides the method defined in Pair to call the first method不能这样编写 Java 代码（在这里，具有相同参数类型的两个方法是不合法的）。它们都没有参数。但是，在虚拟机中，用参数类型和返回类型确定一个方法。因此， 编译器可能产生两个仅返回类型不同的方法字节码，虚拟机能够正确地处理这一情况。
总之，需要记住有关 Java 泛型转换的事实：
- 虚拟机中没有泛型，只有普通的类和方法。
- 所有的类型参数都用它们的限定类型替换。
- 桥方法被合成来保持多态。
- 为保持类型安全性，必要时插人强制类型转换
8.5.4 调用遗留代码
设计 Java 泛型类型时，主要目标是允许泛型代码和遗留代码之间能够互操作。
略。