Java 泛型使用

zhipingChen

发布于 2018-12-24 10:41:47

7910

发布于 2018-12-24 10:41:47

文章被收录于专栏：编程理解

泛型是Java中一项十分重要的特性，在Java 5版本被引入，在日常的编程过程中，有很多依赖泛型的场景，尤其是在集合容器类的使用过程中，更是离不开泛型的影子。

泛型的作用

泛型提供的功能有：参数化类型，以及编译期类型检查。

1 参数化类型

在方法的定义中，方法的参数称为形参，在实际调用方法时传递实参。泛型的使用中，可以将类型定义为一个参数，在实际使用时再传递具体类型。将泛型这种使用方式称之为参数化类型。

在集合类的使用中，若不使用泛型，则需要对每一种元素类型设计相同的集合操作，例如：

class ListInteger{
    //...
}
class ListDouble{
    //...
}

通过泛型的使用，可以避免这种重复定义的现象，定义一套集合操作，来应对所有元素类型，例如：

class List<E>{
    //...
}

在使用中传递不同的元素类型给List即可。

这里使用的字符E并无特殊含义，只是为了便于理解而已。泛型中通常使用的字符及表示意义为： K: 键值对中的key V: 键值对中的value E: 集合中的element T: 类的类型type

2 编译期类型检查

对于集合ArrayList而言，若不指定具体元素类型，则使用过程中可能出现以下情况：

List list = new ArrayList();
list.add("abc");
list.add(123);

for (Object obj : list) {
    String e = (String) obj;//ClassCastException
}

这段代码在编译期没问题，运行时会报出java.lang.ClassCastException。

这种对集合的使用方式存在两个问题：一是add添加元素时，因为元素声明为Object类型，任意类型元素都可以添加到集合中，所以在添加元素时需要使用者自己注意选择的元素类型；二是get取元素时需要强制类型转换，需要用户自己记住添加的元素类型，否则抛出ClassCastException异常。

在声明集合时指定元素类型则可以避免以上两种问题：

List<String> list = new ArrayList<String>();
list.add("abc");
//list.add(123); compile error

for (String obj : list) {
    String e = obj;
}

通过泛型的使用，指定集合元素的类型，则可以在编译期就进行元素类型检查，并且get获取元素时无需进行强制类型转换。

这里称获取元素无需进行强制类型转换，其实并不准确，严格来讲，使用泛型在进行获取元素操作时，进行的是隐式类型转换，所以仍然存在强制类型转换的操作。

ArrayList中的隐式类型转换：

public E get(int index) {
    rangeCheck(index);
    return elementData(index);
}

E elementData(int index) {
    return (E) elementData[index];
}

泛型的使用

泛型可以应用于定义泛型类、泛型接口和泛型方法。

1 泛型类

泛型类的定义方式较为简单，通过将类型抽象为参数，附加在类名称后，即可完成泛型类的定义，示例：

public class Test {
    public static void main(String[] args) {
        User<Integer> user = new User<>();
        user.setAttribute(123);
//        user.setAttribute("abc");compile error
        Integer attribute = user.getAttribute();
    }
}

class User<T> {
    private T attribute;

    public User() {
    }

    public T getAttribute() {
        return this.attribute;
    }

    public void setAttribute(T attribute) {
        this.attribute = attribute;
    }
}

通过使用泛型类，可以在编译期进行参数类型检查，并且使用时无需进行强制类型转换。

2 泛型接口

泛型接口的使用与泛型类较为相似，在接口名称后添加表示类型的字符即可，示例：

interface Person<T> {
    T getAttribute();

    void setAttribute(T attribute);
}

3 泛型方法

在前面的泛型类中定义的如下方法：

    public T getAttribute() {
        return this.attribute;
    }

    public void setAttribute(T attribute) {
        this.attribute = attribute;
    }

虽然使用了参数化类型，但是并不算是泛型方法，因为这些方法中使用的参数类型是泛型类定义的。泛型方法中定义了自己使用的类型，示例：

public <T> void genericsMethod(T parameter){
    //...
}

泛型与继承

在泛型的使用中，关于继承方面需要注意，示例：

public class Test {
    public static void main(String[] args) {
        A<Number> aNumber = new A<>();
        A<Integer> aInteger = new A<>();
//        aNumber = aInteger; compile error
        System.out.println(aNumber.getClass() == aInteger.getClass()); // true
    }
    static class A<T>{}
}

虽然Integer是Number的子类型，但是A<Integer>并不是A<Number>的子类型。事实上，编译器会在编译阶段进行类型检查后，清除泛型的类型信息，也就是说在运行期A<Integer>和A<Number>是同一个类。

泛型使用中的继承定义方式如下：

public class Test {
    public static void main(String[] args) {
        A<Integer> a = new A<>();
        B<Integer> b = new B<>();
        a = b;
    }
}
class A<T>{}
class B<T> extends A<T>{}

在继承关系中使用同一个参数类型，以此实现泛型类的继承。在JDK中ArrayList<E>、List<E>与Collection<E>采用的就是这种方式。

但是这种继承方式依然不能满足前面提到的使用场景，例如如下使用List方式：

public class Test {
    public static void main(String[] args) {
        List<Number> numberList = new ArrayList<>();
        List<Integer> integerList = new ArrayList<>();
//        numberList = integerList; compile error
    }
}

虽然Integer是Number的子类型，但List<Integer>却不是List<Number>的子类型，问题与前面的示例中相同。

通配符

通配符号?是一种实参类型，表示类型不确定的意思，或者表示任意一种类型，选择?作为类型的目的是为了匹配更大范围的类型，所以这里?是一种具体的类型。

这里称?类型不确定，又称?是一种具体的类型，这种说法是相对于前面的类型参数T而言的，T表示类型形参，使用时被替代为传入的具体类型，而?就是一种具体类型，不会被别的具体类型替代。

在前面有关泛型的继承关系中，遇到List<Integer>不是List<Number>的子类型问题，可以使用通配符号?表示具体类型，这样则可以匹配任意的参数类型，示例：

public class Test {
    public static void main(String[] args) {
        List<?> numberList = new ArrayList<>();
        List<Integer> integerList = new ArrayList<>();
        numberList = integerList; 
    }
}

既然?可以表示所有类型，当然也可以表示Integer类型，所以代码可以编译通过。

在平常的使用中，类型的选择范围并非如此随意，更多时候在定义泛型类、接口或方法时，限定了能够使用的类型范围。

1 限定上界

使用extends关键字限定参数类型能够选择的上界，示例：

public class Test {
    public static void main(String[] args) {
        GenericsClass<Integer> integerObj = new GenericsClass<>();
//        GenericsClass<String> stringObj = new GenericsClass<>(); compile error
        
        Test.genericsMethod1(new ArrayList<Integer>());
//        Test.genericsMethod1(new ArrayList<String>()); compile error

        Test.genericsMethod2(new ArrayList<Integer>());
//        Test.genericsMethod2(new ArrayList<String>()); compile error
    }
    static class GenericsClass<T extends Number>{
        //...
    }
    static <T extends Number> void genericsMethod1(List<T> list) {
//        list.add(1); compile error
    }
    static void genericsMethod2(List<? extends Number> list) {
//        list.add(1); compile error
    }
}

GenericsClass类中通过<T extends Number>限定参数类型为Number的子类型，genericsMethod1、genericsMethod2同样使用extends关键字限定类型上界。

genericsMethod1与genericsMethod2分别使用了T和?作为参数类型符号，在限定类型范围上，两者作用相同。不同之外在于，使用T表示类型形参，在genericsMethod1方法体内可以引用T类型相关的操作，但是?则无法引用。

这里需要注意一点，若使用具有上界的泛型来作为集合的元素类型时，因为此时无法确定集合的元素类型，所以无法向集合中添加元素，示例：

    static <T extends Number> void genericsMethod1(List<T> list) {
//        list.add(1); compile error
    }
    static void genericsMethod2(List<? extends Number> list) {
//        list.add(1); compile error
    }

2 限定下界

使用super关键字限定参数类型能够选择的下界，示例：

public class Test {
    public static void main(String[] args) {
        Test.genericsMethod2(new ArrayList<Integer>());
//        Test.genericsMethod2(new ArrayList<String>()); compile error
    }
//    static class GenericsClass<? super Integer>{ compile error
//        //...
//    }
//    static <T super Integer> void genericsMethod1(List<T> list) { compile error
//        //...
//    }
    static void genericsMethod2(List<? super Integer> list) {
        list.add(1); 
    }
}

由示例可知，<? super Integer>的形式限定元素的下界为Integer类型，则此时可以对集合进行添加Integer元素操作。

由示例同样可知，使用super关键字限定参数类型下界，与使用extends关键字限定参数类型的上界有所不同，最大的区别就是：类型形参T不能与super关键字配合使用。若可以配合使用，则会存在以下问题：

<T extends Integer>表示T类为Integer的子类型，则T类型属性可以访问Integer类型中的部分属性；<T super Integer>的描述表示T类为Integer的父类，则T类型属性不确定其父类为何类，也可能为Serializable，那么此时将不具备任何属性，因为不确定，所以无法进行操作；
<T extends Integer>在编译时进行类型擦除后，则T属性将默认为extends继承的父类中最左边一个，这里即为Integer；而<T super Integer>描述的类，在进行类型擦除后将无法确定其类型。

根据以上两点，在类的描述中，不能使用<T super Integer>的形式限定参数类型的下界。

通配符的上下界使用有PECS(producer extends, consumer super)原则，producer可以根据上界进行元素读取，但是不确定类型，所以无法添加元素；consumer可以根据下界进行元素添加，但是不确定类型，所以无法读取元素。

泛型数组

在普通数组的使用中，存在如下的情况：

public class Test {
    public static void main(String[] args) {
        Integer[] integers = new Integer[5];
        Object[] objects = integers;
        objects[0] = "abc";
    }
}

这段代码在编译期是没问题的，在运行时会报出ArrayStoreException异常。这种情况称之为数组的协变(covariant)，即S类型为T类型的子类型，则S类型数组为T类型数组的子类型。

Java禁止创建具体类型的泛型数组，并不禁止创建通配符形式的数组，不过相对于数组在运行时进行元素类型的检查，泛型的使用能够在编译期给出类型错误提示，示例如下：

public class Test {
    public static void main(String[] args) {
//        List<Integer>[] integers = new ArrayList<>[5]; compile error
        List<?>[] lists = new ArrayList<?>[5];
        List<String> stringList = new ArrayList<>();
        lists[0] = stringList;
//        lists[0].add(1.3); compile error
    }
}

引用

Type Parameters Difference between <? super T> and <? extends T> in Java

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2018.12.24 ，如有侵权请联系 cloudcommunity@tencent.com 删除

java

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

java

登录后参与评论

0 条评论

热度