深入解析Java泛型类的原理与应用（1）

泛型方法：

 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)
    {
       /* if(a==null||a.length==0)
 {
 return null;
 } */
        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)方法。这个方法是合成的桥方法，这正是我们所期望的操作效果。