泛型方法：
public class ArrayAlg
{
public static T getMiddle(T...a)
{
return a[a.length/2];
}
}
这个方法是从普通类中定义的，而不是在泛型类中定义的。然而，这个一个泛型方法，可以从尖括号和类型变量看出这一点。注意，类型变量放在修饰符public static 的后面，在返回类型的前面。
泛型方法可以定义在普通类中，也可以定义在泛型类中。
当调用一个泛型方法时，在方法明前的尖括号内放入具体的类型：
String middle=ArrayAlg.<String>getMiddle("a","b","c");
在这种情况下（实际上也是大多数情况下），方法调用中可以省略类型参数。编译器有足够的信息能够判断出所调用的方法。他用names的类型（即String[])与泛型类型T[]进行匹配并推断出T一定是String。也就是说，可以调用：
String middle=ArrayAlg.getMiddle("a","b","c");
几乎在大多数情况下，对于泛型方法的类型引用没有问题。偶尔，编译器也会提示错误，此时需要解译错误报告。看看下面的实例：
double middle=ArrayAlg.getMiddle(3.14,1729,0);
错误消息会以晦涩的方法指出（不同的编译器给出的错误信息可能不同）：解释这句代码有两种方法，而且这两种方法都是合法的。简单地说，编译器将会自动打包参数为1个Double和两个Integer对象，而后寻找这些类的共同超类型。事实上，找到这两个这样的超类型：Number和Comparable接口，其本身也是一种泛型类。这种情况下，可以采取的补救措施是将所有的参数写为double值。
类型变量的限定
有时，类或者方法需要对类型变量加以约束。下面是一个典型的例子。我们要计算数组中的最小元素：
class ArrayAlg
{
public static T min(T[] a)
{
if(a==null||a.length==0)
return null;
T smallest=a[0];
for(int i=0;i if(smallest.comparaTo(a[i]) >0)
smallest =a[i];
return smallest;
}
}
但是，这里有一个问题。请看一下min方法的内部。变量smallest类型为T，这意味着smallest可能为任何类型的对象。那么怎么才能确信T所属的类由compareTo方法呢？
解决这个问题的方案是将T限制为实现了Comparable接口（只含一个方法comparaTo的标准接口）的类，可以通过对类型T设置限定（bound）实现这一点：
public static T min(T[] a)
实际上Comparable接口本身就是一个泛型类型。目前，我们忽略其复杂性以及编译器产生的警告。
现在，泛型的min方法只能被实现了Comparable接口的类（如String、LocalDate等）的数组调用。由于Rectangle类没有实现Comparable接口，所以调用min会产生一个编译错误。
读者或许感到奇怪——在此为什么使用关键字extends而不用implements? 毕竟Comparable是一个接口。下面的记法：
表示T应该是绑定类型的子类型（subtype）。T和绑定类型可以是类，也可以是接口。选择关键字extends的原因是更接近子类的概念，并且Java的设计者也不打算在语言中再添加一个新的关键字（如sub）
一个类型变量或者通配符可以有多种限定，例如：
T extends Comparable & Serializable
限定类型用“&”分隔，而逗号用来分隔类型变量。
在java的继承中，可以根据需要拥有多个接口超类型，但限定中至多有一个类。如果用一个类作为限定，他必须是限定列表中的第一个。
在程序清单中，重新编写了一个泛型方法minmax。这个方法计算泛型数组的最大值和最小值，并返回Pair
示例程序
package NEW_DATE_SEQUENCE_PACKAGE;
import java.time.LocalDate;
/**
*
* @author cmx
*/
public class J_8_29_1
{
public static void main(String[] args)
{
LocalDate [] birthdays=
{
LocalDate.of(2000, 1, 2),
LocalDate.of(2001, 1, 2),
LocalDate.of(2003, 1, 1)
};
Pair minmax1=ArrayAlg.minmax(birthdays);
LocalDate max=minmax1.getSecond();
LocalDate min=minmax1.getFirst();
System.out.println(max);
System.out.println(min);
}
}
class ArrayAlg
{
public static Pair minmax(T[] a)
{
T min=a[0];
T max=a[0];
for(int i=1;i {
if(min.compareTo(a[i])>0)
min=a[i];
if(max.compareTo(a[i])<0)
max=a[i];
}
return new Pair<>(min,max);
}
}
class Pair
{
private T first;
private T second;
public Pair()
{
}
public Pair(T first,T second)
{
this.first=first;
this.secOnd=second;
}
public T getFirst()
{
return first;
}
public T getSecond()
{
return second;
}
}
泛型代码和虚拟机
虚拟机没有泛型类型对象——所有的对象都属于普通类。在泛型实现的早期版本中，甚至能够将使用泛型的程序编译为在1.0虚拟机上运行的类文件！这个向后兼容性在Java泛型开发的后期被放弃了。
类型擦除（擦出的是T）
无论何时定义一个泛型类型，都自动提供了一个相应的原始类型（raw type）。原始类型的名字就是删去类型参数后的泛型类型名。（Pair的原始类型为Pair，类型参数为T）。擦除（erased）类型变量（如 T )，并替换为限定类型（无限定类型的变量用Object）（如String）。
例如：Pair的原始类型如下所示：
原始类型<类型参数> —类型擦除，擦除类型参数—>得到原始类型Pair—-> 将类型参数替换为限定类型
class Pair
{
private Object first;
private Object second;
public Pair(Object first,Object second)
{
this.first=first;
this secOnd=second;
}
public Object getFirst()
{
return first;
}
public Object getSecond()
{
return second;
}
}
因为T是一个无限定的变量，所以直接用Object替换
结果是一个普通的类，就好像泛型引入java语言之前已经实现的那样。
在程序中可以包含不同类型的Pair，例如，Pair或者Pair.而擦除类型后就变成原始的Pair类型了。
C++注释：就这点而言，Java泛型与C++模板有很大的区别。C++中每个模板的实例化产生不同的类型，这一现象称为模板代码膨胀。Java中不存在这个问题的困扰。
原始类型用第一个限定的类型变量来替换，如果没有给定限定就用Object替换。例如，类Pair中的类型变量没有显示的限定，因此，原始类型用Object替换T。假设声明了一个不同的类型。
public class Interval <T extends Comparable & Serializable> implements Srializable
{
private T lower;
private T upper;
public Intervel(T first ,T second)
{
if(first.compareTo(second)<=0)
{
lower=first;
upper=second;
}
else
{
lower=second;
upper=first;
}
}
}
原始类型intervel如下所示：
public class Intervel implements Serializable
{
private Comparable lower；
private Comparable upper；
public Intervel（Comparable first ，Comparable second）
{
}
}
注释：切换限定：
class Interval <T extends Serializable & Comparable >
会发生什么。如果这样做，原始类型用Serializable替换T，而编译器在必要时要向Comparable插入强制类型转化。为了提高效率，应该将标签（tagging）接口（即没有方法的接口，比如Serializable）放在边界列表的末尾。
翻译泛型表达式
当程序调用泛型方法时，如果擦除返回类型，编译器插入强制类型转换。例如，下面这个语句序列：
Pair buddies=...;
Employee buddy=buddies.getFirst();
擦除getFirst的返回类型会将返回Object类型。编译器自动插入Employee类型的强制类型转换。也就是说，编译器把这个方法调用翻译为两条虚拟机指令：
对原始方法Pair.getFirst的调用
将返回的Object类型强制转换为Employee类型
当存取一个泛型域时也要插入强制类型转换。假设Pair类的first域和second域都是公有的（也许这不是一种好的编程风格），但是在java中是合法的）。表达式：
Employee buddy=buddies.first
翻译泛型方法
类型擦除也会出现在泛型方法中。程序员通常认为下述的泛型方法
public static 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 DateIntervel extends Pair
{
public void setSecond(LocalDate second)
{
if(second.compareTo(getFirst())>=0)
super.setSecond(second)
}
}
令人感到奇怪的是，存在另一个从Pair继承的setSecond方法，即
public void setSecond(Object second)
这显然是一个不同的方法，因为它有一个不同类型的参数——Object，而不是LocalDate。然而，不应该不一样，考虑下面的语句序列：
DateIntervel interval =new DateIntervel();
Pair < LocalDate> pair = intervel;
pair.setSecond(aDate);
这里，希望对setSecond的调用具有多态性，并调用最合适的那个方法。由于pair引用DateInterval对象，所以就应该调用DateInterval.setSecond类中生成的一个桥方法（bridge method）：
public void setSecond(Object second)
{
setSecond(Date) second;
}
要想了解他的工作过程，请仔细的跟踪下列语句的执行
pair.setSecond(aDate)
变量pair已经声明为类型Pair,并且这个类型只有一个简单的方法叫setSecond，即setSecond（Object）。虚拟机用pair引用的对象调用这个方法。这个对象是DateInterval类型的，因而会调用DateInterval.setSecond(Object)方法。这个方法是合成的桥方法，这正是我们所期望的操作效果。
京公网安备 11010802041100号