Java 泛型

public class Pair<T> {
private T first;
private T second;
public Pair(T first, T second) {
this.first = first;
this.second = second;
}
public void setSecond(Object second) {
setSecond((Date)second);
}
变量pair已经声明为类型Pair<Date>，并且该类型只有一个简单的方法叫做setSecond(Object)。虚拟机用pair引用的对象调用了这个方法。该对象是DateInterval类型的。因此，将会调用DateInterval类的setSecond(Object)方法。该方法是合成的桥方法。它调用DateInterval类的setSecond(Date)方法，这正是我们想要做的。
ArrayList<String> array = new ArrayList<String>();
-------------------------------------------
***具有一个或多个类型变量的类就是泛型类***
-------------------------------------------
如：public class Interval<T extends Comparable & Serializable>用comparable替换。
如：public class Interval<T extends Serializable & Comparable>用Serializable替换。
}
}
public Date getSecond() {
}
......
}
一个日期区间是一对Date对象表示，并且我们要想覆盖这个方法以确保第二个值永远不小于第一个值
类型擦除后变为。
class DateInterval extends Pair {
DateInterval interval = new DateInterval(...);
Pair<Date> pair = interval;
pari.setSecond(aDate);
Date d = (Date)pari.getSecond();
我们希望对setSecond的调用是多态的，因为pair引用DateInterval对象，所以应该调用DateInterval的setSecond方法。问题在于类型擦除与多态发生了冲突。要解决这个问题就需要编译器在子类中生成一个桥方法
public class Pair {
private Object first;
private Object second;
public Pair(Object first, Object second) {
this.first = first;
this.second = second;
总之，要记住有关Java泛型转换的事实：
虚拟机中没有泛型，只有普通的类和方法。
所有的类型参数都用它们的限定类型(边界)替换。
桥方法被合成为保持多态的。
为保持类型安全性，很必要时插入强制类型转换。
七、调用遗留代码
5.0之前。有很多类需要ArrayList之类的类。5.0之后它们都是泛型类，如果泛型类不能与这代码互操作，就不能被广泛地应用。幸运的是，可以直接把泛型类与遗留的API中原始的对应物放在一起使用。
上面的语句好似给类型变量E赋了值，它的值为String。之后我们可以把这个类理解为如下样式：
public class ArrayList {
......
public boolean add(String o) {
......
}
public String get(int index) {
public void setSecond(Date second) {
......
}
}
但是还存在另一个从Pair继承的setSecond方法，即
public void setSecond(Object second)
这显然是一个不同的方法，因为它有一个不同的参数类型－－Object，而不是Date。
假设DateInterval也覆盖了getSecond方法：
class DateInterval extends Pair<Date> {
public Date getSecond() {
return (Date)super.getSecond();
}
}
在被擦除的类型中，有两个getSecond方法：
五、翻译泛型表达式
当程序调用泛型方法时，如果返回类型被擦除，编译器插入强制类型转换。
pair<Employee> buddies = ......;
Employee buddy = buddies.getFirst();
编译器把这个方法调用翻译为如下形式：
Employee buddy = (Employee)buddies.getFirst();
}
}
String[] values = {"One", "Two", "Three", "Four", "Five"};
String value = Test.<String>getMiddle(values);
通常我们会在方法调用时省略<String>类型参数。编译器可以根据values的类型肯定泛型类型的匹配
......
public boolean add(E o) {
......
}
public E get(int index) {
......
}
}
这里用的是String来替换类型变量E。这时这个ArrayList类中的所有类型变量E都用String类型来替换。那么这个数组列表只可以装载String类型的对象。
六、翻译泛型方法
类型擦除也会出现在泛型方法中。
public static <T extends Comparable> T min(T[] a)
方法在擦除之后，如以下形式。
public static Comparable min(Comparable[] a)
注意：方法的擦除带来了两个复杂的问题。
public T getFirst() {
return this.first;
}
public T getSecond() {
return this.second;
}
}
因为T是一个无限定的类型变量，所以简单地用Object替换。Pair<T>的原始类型如下所示：
}
}
-----------------------------
二、泛型方法
泛型方法可以定义在泛型类中，也可以不定义在泛型类中
public class Test {
public static <T> T getMiddle(T[] array) {
return array[arr.length / 2];
}
public Object getFirst() {
return this.first;
}
public Object getSecond() {
return this.second;
}
}
----------------------------------
......
}
多个限定用"&"分开。
T extends Comparable & Serializable
-----------------------------
四、泛型代码和虚拟机
虚拟机没有泛型类型－－所有对象都属于普通类。
无论何时定义一个泛型类型，相应的原始类型都会被自动提供。原始类型的名字就删去了类型参数的泛型类型的名字。类型变量被擦除，并用其第一个限定类型替换。无限定的变量用Object替换。
c class Pair<T> {
private T first;
private T second;
public Pair(T first, T second) {
this.first = first;
this.second = second;
}
public T getFirst() {
return this.first;
}
public T getSecond() {
return this.second;
}
public void setSecond(T second) {
this.second = second;
public static void main(String[] args) {
Entry<String,String> entry = new Entry<String,String>("name", "Mike");
String name = entry.get("name");