（十七）泛型程序设计

为什么使用泛型程序设计

泛型程序设计意味着编写的代码可以被很多不同类型的对象所重用。

定义简单的泛型类

一个泛型类就是具有 “一个或多个类型变量” 的类。

以下定义一个泛型类：

public class Pair<T> {
    private T first;
    private T second;
    public Pair(){
        first=null;
        second=null;
    }
    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 setFirst(T first){
        this.first = first;
    }
    public void setSecond(T second){
        this.second = second;
    }
}

以下定义一个ArrayAlg类，其minmax方法用于字符串数组查找，并将返回的结果存于Pair的对象。

public class PairTest1 {

    public static void main(String[] args) {
        String[] words = {"qggere","jrtrew","qegre","hefgqe","dggre"};
        Pair<String> pair = ArrayAlg.minmax(words);
        System.out.println("min:"+pair.getFirst());
        System.out.println("max:"+pair.getSecond());
    }

}
class ArrayAlg{
    public static Pair<String> minmax(String[] a){
        if(a==null||a.length==0) return null;
        String min = a[0];
        String max = a[0];
        
        for(int i=1;i<a.length;i++){
            if(min.compareTo(a[i])>0) min=a[i];
            if(max.compareTo(a[i])<0) max=a[i];
        }
        return new Pair<String>(min,max);
    }
}

泛型方法

class ArrayAlg{
    public static <T> T getMiddle(T...a){
        return a[a.length/2]; 
   }
}

类型变量放在修饰符后面（public static），返回类型的前面。

调用一个泛型方法时，在方法名前面的尖括号中放入具体的类型。

String middle = ArrayAlg.<String>getMiddle("dwa","adw","fwfw");

类型变量的限定

class ArrayAlg{
    public static <T extends Comparable> T min(T[] a){
        if(a==null||a.length==0) return null;
        T smallest = a[0];
        for(int i=1;i<a.length;i++){
            if(smallest.compareTo(a[i])>0) smallest = a[i];
        }
        return smallest;
    }
}

如上，smallest的类型为T，是一个不确定的类型，当我们调用smallest.compareTo时，无法确定T类有此方法，因此通过<T extends Comparable>限定T类是一个实现了Comparable接口的类。

当有多个限定类型时，可以这样：<T extends Comparable & Serializable,V extends Comparable & Serializable>。限定类型用&隔开，类型变量用逗号隔开。

泛型代码和虚拟机

虚拟机没有泛型类型对象——所有对象都属于普通类，即泛型代码中的“T t”这种对象变量的声明会把T转换为普通类。而这个普通类称为原始类型，它是删去类型参数后的泛型类型名。擦除类型变量，并替换为限定类型。

如下原始代码：

 

public class Pair<T extends Comparable> {
    private T first;
    private T second;
    public Pair(){
        first=null;
        second=null;
    }
    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 setFirst(T first){
        this.first = first;
    }
    public void setSecond(T second){
        this.second = second;
    }
}

 

在虚拟机中会替换类型变量，由于类型变量的限定类型是Comparable，则原始类型用Comparable来替换，如果有多个限定类型，原始类型使用第一个限定类型。如果没有限定类型，则用Object替换。得到原始类型如下：

public class Pair{
    private Comparable first;
    private Comparable second;
    public Pair(){
        first=null;
        second=null;
    }
    public Pair(Comparable first,Comparable second){
        this.first = first;
        this.second = second;
    }
    
    public Comparable getFirst(){
        return this.first;
    }
    public Comparable getSecond(){
        return this.second;
    }
    
    public void setFirst(Comparable first){
        this.first = first;
    }
    public void setSecond(Comparable second){
        this.second = second;
    }
}

翻译泛型表达式

程序调用泛型方法时，如果擦除返回类型，编译器插入强制类型转换。如下:

Pair<Employee> buddies = ...
Employee buddy = buddies.getFirst();

如果泛型方法的原始类型是Object，则擦除getFirst()方法的返回类型后返回Object类型，然后再进行Employee的强制类型转换。

翻译泛型方法

类型擦除也会出现在泛型方法中。这带来一些复杂的问题。

class DateInterval extends Pair<Date>{
    public void setSecond(Date second){
        if(second.compareTo(getFirst())>=0)
            super.setSecond(second);    
    }
}

以上代码存在一个从Pair继承的setSecond()方法，它有一个不同的参数Object，而不是Date。考虑以下代码：

DateInterval interval = new DateInterval(...);
Pair<Date> pair = interval;
pair.setSecond(aDate);

由于pair引用了DateInterval的对象，所以我们调用pair.setSecond的方法时，我们希望调用的是DateInterval的setSecond方法。然而类型擦除和多态产生冲突。因为Pair的方法setSecond的参数类型是Object，而它的子类对应的方法setSecond的参数是Date。当父类引用指向子类对象时，父类引用调用的一定是父类的方法，只有子类覆盖父类的方法时才调用子类方法。因此上面的代码只会调用Pair的setSecond方法。

因此，为了解决这个问题，需要使用桥方法：

 public void setSecond(Object second){
    setSecond((Date) second);
}

约束与局限性

不能用基本类型实例化类型参数

如Pair<double>是错误的。

运行时类型查询只适用于原始类型

所有的类型查询只产生原始类型。

Pair<String> stringPair = ...
Pair<Employee> stringPair = ...
if(stringPair.getClass()==stringPair.getClass()) //左式返回true

上面两个对象调用getClass()方法，返回的都是Pair.class。

不能创建参数化类型的数组

如：Pair<String>[] table = new Pair<String>[10];