泛型程序设计

　　使用泛型机制编写的程序代码要比那些杂乱的使用Object变量，然后进行强制类型转换的代码具有更好的安全性和可读性。泛型对于集合类尤其有用，例如，ArrayList就是一个无处不在的集合类。

泛型程序设计意味着编写的代码可以被很多不同类型的对象所重用。一个ArrayList类可以聚集任何类型的对象。这是一个泛型程序设计的实例。

泛型提供了一个更好的解决方案：类型参数。ArrayList类有一个类型参数用来指示元素的类型：

ArrayList<String> files = new ArrayList<String>();

这使得代码具有更好的可读性。人们一看就知道这个数组列表中包含的是String对象。

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

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 first;
    }
    public void setFirst(T first) {
        this.first = first;
    }
    public T getSecond() {
        return second;
    }
    public void setSecond(T second) {
        this.second = second;
    }
}

public class PairTest1 {
    public static void main(String[] args) {
        String[] words = {"Mary","had","a","little","lamb"};
        Pair<String> mm = ArrayAlg.minmax(words);
        System.out.println("min="+mm.getFirst());
        System.out.println("max="+mm.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=0;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<>(min,max);
    }
}

min=Mary
max=little

泛型方法。

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

这个方法是在普通类中定义的，而不是在泛型类中定义的。注意，类型变量放在修饰符（这里是public static）的后面，返回类的前面。

泛型方法可以定义在普通类中，也可以定义在泛型类中。

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

public class PairTest2 {
    public static void main(String[] args) {
        String middle = ArrayAlg1.<String>getMiddle("Hohn","Q.","Public");
        System.out.println(middle);
        
    }

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

返回Q.

在这种情况下，方法调用中可以省略<String>类型参数。编译器有足够的信息能够推断出所调用的方法。