java 范型

一、范型代码的格式

可以是范型类也可以范型方法

1、范型类

class ClassName<T, ....> {

......ClassName的属性和方法

}

如上跟普通的类相比，增加了<T, ....>

如下是一个简单的Pair的例子，增加了T的类型，则Pair的first和second可以是创建的时候指定的类型

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 T getSecond() {
        return second;
    }

    public void setFirst(T newValue) {
        first = newValue;
    }

    public void setSecond(T newValue) {
        second = newValue;
    }
}

如果我们要让first跟second不同类型，可以有多格范型。如下所示

class Pair<T, U> {
    private T first;
    private U second;

    public Pair() {
        first = null;
        second = null;
    }

    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public U getSecond() {
        return second;
    }

    public void setFirst(T newValue) {
        first = newValue;
    }

    public void setSecond(U newValue) {
        second = newValue;
    }
}

 

2、范型方法

<T> T Method(T a) {

}

如上跟普通的方法区别是在最前面增加了<T>的限定，告诉Method可以使用T类型

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

 

二、有时也需要对范型类型做限定

如果我们对一个参数做比较的时候则该参数的类型需要支持Comparable，那么我们需要对范型类型做限定：<T extends Comparable>

之前我们如果类要遵循协议那么用implements，如果要继承父类则用extends

但是类型的限定全部用extends

那么多继承的话则使用& 进行隔开

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

        return smallerst;
    }

如上是对T做限定Comparable，因为有Comparable才能使用compareTo，否则编译器不知道是否有compareTo这个函数

class Interval<T extends Comparable & Serializable> implements Serializable {
    private T lower;
    private T upper;

    public Interval(T first, T second) {
        if (first.compareTo(second) <= 0) {
            lower = first;
            upper = second;
        } else {
            lower = second;
            upper = first;
        }
    }
}

如上是多个限定

 

三、范型代码和虚拟机

虚拟机没有范型类型对象即所有对象都属于普通类；假设有如下的类，那么虚拟机对应的原始类型是怎样的呢

class Interval<T extends Comparable & Serializable> implements Serializable {
    private T lower;
    private T upper;

    public Interval(T first, T second) {
        if (first.compareTo(second) <= 0) {
            lower = first;
            upper = second;
        } else {
            lower = second;
            upper = first;
        }
    }
}

如上对应的原始类型是

class Interval implements Serializable {
    private Comparable lower;
    private Comparable upper;

    public Interval(Comparable first, Comparable second) {
        if (first.compareTo(second) <= 0) {
            lower = first;
            upper = second;
        } else {
            lower = second;
            upper = first;
        }
    }
}

 

那么如果将Comparable & Serializable改为Serializable & Comparable会发生什么事情呢？

调换之后Interval对应的原始类型则替换为

class Interval implements Serializable {
    private Serializable lower;
    private Serializable upper;

    public Interval(Serializable first, Serializable second) {
        if (((Comparable)first).compareTo(second) <= 0) {
            lower = first;
            upper = second;
        } else {
            lower = second;
            upper = first;
        }
    }
}

在对比的时候会做一次的强转

为了提高效率则应该将接口放在限定列表的末尾。（这句话摘录自java核心技术卷一）