（十七）泛型程序设计

Posted 2020-08-15 且听风吟-wuchao

为什么使用泛型程序设计

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

定义简单的泛型类

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

以下定义一个泛型类：

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>。限定类型用&隔开，类型变量用逗号隔开。