(十七)泛型程序设计

为什么使用泛型程序设计

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

定义简单的泛型类

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

以下定义一个泛型类:

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];

 

 

 

 

posted @ 2016-10-18 21:33  且听风吟-wuchao  阅读(362)  评论(0编辑  收藏  举报