Java面向对象程序设计--泛型编程

1. 为何要进行泛型编程？

泛型变成为不同类型集合提供相同的代码！省去了为不同类型而设计不同代码的麻烦！

2. 一个简单泛型类的定义:

---

public class PairTest1 
{
    public static void main(String[] args) 
    {
        String[] arr = {"This","is","the","end","of","the","world"};
        Pair<String> mm = ArrayAlg.minmax(arr);
        System.out.println("min = " + mm.getFirst());
        System.out.println("max = " + mm.getSecond());
    }
}

class Pair<T>
{
    public Pair() {first = null; second = null;}
    public Pair(T first,T second) {this.first = first; this.second = second;}
    
    public T getFirst() {return first;}
    public T getSecond() {return second;}

    public void setFirst(T newValue) {this.first = newValue;}
    public void setSecond(T newValue) {this.second = newValue;}
    
    private T first;
    private T second;
}

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);
    }
}

上面这段代码中定义了一个泛型类。

2. 泛型函数：

下面是一个泛型函数定义的实例:

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

注意，一个泛型函数可以定义在一个普通类中，也可以定义在一个泛型类中。

 注意在上述模板函数的定义中，模板参数变量的位置，是出现在public static 修饰符之后的！

下面是模板函数的调用:

        String[] arr = {"this","is","me"};
        String middle = ArrayAlg.<String>getMiddle(arr);
        System.out.println(middle);

在实际中，调用泛型函数时并不需要在函数前加上<String>操作符。java会自动进行类型检查，比如上面getMiddle会自动检查出参数arr的类型是String[]的，这样推测出

T的类型是String。

3. 类型变量的约束:

public static <T extends Comparable> Pair<T> minmax(T[] a)
    {
        if(a == null || a.length == 0) return null;
        T min = a[0];
        T 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<T>(min,max);
    }

这里为类型变量T添加了约束T extends Comparable，要求T实现Comarable接口中的CompareTo函数！

Java中泛型变量的约束条件是： <T extends BoundingType>, 你可以让T继承一个类，或者继承任意一个接口，或者同时继承一个类和一个接口，但无论如何

不能继承多个类！

4.泛型代码和虚拟机之间的关系:

虚拟机中没有泛型类型的对象，所有的对象都是具体的类型的对象。

当定义了一个泛型类型之后，编译器会自动提供一个相对应的原始类型(raw type):

raw type的类型名和泛型类型名相同，只是泛型类型参数被去掉了。类型变量被替换成成限定类型对象或Object类型对象。

class Pair<T>
{
    public Pair() {first = null; second = null;}
    public Pair(T first,T second) {this.first = first; this.second = second;}
    
    public T getFirst() {return first;}
    public T getSecond() {return second;}

    public void setFirst(T newValue) {this.first = newValue;}
    public void setSecond(T newValue) {this.second = newValue;}
    
    private T first;
    private T second;
}

上面的类型对应的原始类型是：

class Pair<T>
{
    public Pair() {first = null; second = null;}
    public Pair(Object first,Object second) {this.first = first; this.second = second;}
    
    public Object getFirst() {return first;}
    public Object getSecond() {return second;}

    public void setFirst(Object newValue) {this.first = newValue;}
    public void setSecond(Object newValue) {this.second = newValue;}
    
    private Object first;
    private Object second;
}