Java的泛型

版权声明：本文系博主原创，未经博主许可，禁止转载。保留所有权利。

引用网址：https://www.cnblogs.com/zhizaixingzou/p/9992847.html

 

目录

 

1. 泛型

1.1. 解决什么问题

先来看如下的一个类，它封装了一个String类型的值。

public class StringEntry {
    private String value;

    public void setValue(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }
}

现在，我需要再封装一个Integer类型的值，一个很自然的想法是再定义一个IntegerEntry类。然而此法有不足之处，即如果我需要再封装一些其他类型的值，那么就需要再定义对应的这么多的类，哪怕它们的定义如此类似，即复用性不好。

 

考虑到Object类是所有类的超类，可以定义一个类，用它来封装Object类型的值，定义了这个类，就不用再定义上面的许多类了。

public class ObjectEntry {
    private Object value;

    public void setValue(Object value) {
        this.value = value;
    }

    public Object getValue() {
        return value;
    }
}

这样的实现，也是早期Java实现集合框架采用的策略：继承多态。

 然而，这个基于Object继承的多态实现有两个问题：一是get方法返回的是Object对象，使用该对象时需要显式地强制转换为我们需要的类型，二是使用set方法时，即使加入了我们不期望的类型的对象，编译器也不会产生任何的错误提示，我们取出该对象时，若仍按期望的类型转换就会抛异常，即类型不安全。

 

从C++的类型模板特性得到启发，Java在Java 5引入了泛型的概念以解决这个问题。就是在定义一个类时可以加入类型参数，使类成为泛型类。

public class Entry<T> {
    private T value;

    public void setValue(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

这样以后，在外部使用get方法时，如果用类型参数的实际类型的变量来接纳它，那么返回的就是我们需要的类型的实例，无须强制转换，因为编译器自动加入了类型转换指令（当然，如果没有变量接纳，而单纯调用get方法，则返回类型参数的边界类型的实例）。对应地，在外部使用set方法时，如果传入的不是我们期望的类的实例，则会编译报错，这是编译器在编译时自动进行类型检查的缘故。总之，在使用泛型类时，编译器会帮我们自动完成类型检查和强制转换的工作。

1.2. 泛型的用法

1.2.1. 声明泛型类的变量时可给出类型参数的实际类型

对于上面定义的Entry<T>，可以像下面这样使用。

public static void main(String[] args) {
    Entry<String> entry = new Entry<String>();
    entry.setValue("hello world");
}

可以看到，声明泛型类的变量时可给出类型参数的实际类型。当然，这里的“给出类型参数的实际类型”的“实际类型”可以是确定的，如这里的String，也可以不确定，而是一个范围，也就是后面要讲的通配符。

1.2.2. 可为类型参数指定边界类型

可为类型参数指定边界类型，如下。

<T extends Comparable<T>>
<K, V extends Vector & Runnable>

其中，extends后的类型为边界类型，可以是一个类或接口，或后面还可以使用“&”连接多个接口。

<E>实际等效于<E extends Object>。

指定边界类型的好处在于，可以确定类型参数具有边界类型的某些方法，以便编译期就可以使用这些方法，如上面的T类型的实际类型必然具有compareTo方法。

1.2.3. 泛型类可以有多个类型参数

所谓泛型类，是指具有一个或多个类型参数的类。

public class Pair<K, V> {
    private K key;
    private V value;

    public void setKey(K key) {
        this.key = key;
    }

    public K getKey() {
        return key;
    }

    public void setValue(V value) {
        this.value = value;
    }

    public V getValue() {
        return value;
    }
}

泛型类Pair<K, V>的类型参数为K、V。这里的K为Key的首字母，代表键的意思，V为Value的首字母，代表值的意思。常用的类型参数名还有E（Element）、T（Type）等，当然用其他字母也是可以的。

 

泛型类的使用如下。

Pair<String, Integer> pair = new Pair<String, Integer>()

1.2.4. 泛型方法的定义和使用

所谓泛型方法，是带有类型参数的方法，既可以定义在泛型类中，也可以定义在普通类中。

public class Util {
    public static <K, V> boolean process(Pair<K, V> pair) {
        return true;
    }
}

类型参数定义于修饰符的后面和返回类型的前面，之所以不放在方法名后，是因为返回类型也可能是类型参数指定的类型。

 

泛型方法的使用如下。

Util.<String, Integer>process(new Pair<String, Integer>())

或者

Util.process(new Pair<String, Integer>())

后一个利用了Java 1.7引入的类型推导。

1.2.5. 类型参数的继承关系不会传递给泛型类

1.2.5.1. 不同类型参数的泛型类实例无关系

虽然String是Object的子类，但是Entry<String>却不是Entry<Object>的子类，它们甚至都不是类与类的关系，它们都属于Entry的一种使用方式。也就是说，类型参数的继承关系不会传递给泛型类实例。在这里，我们不妨创造一个概念，就是泛型类实例，它不是类的概念，也不是对象的概念，乃是对泛型类的一种使用方式，也可以叫泛型类的使用模式，不同的模式，对应着不同的类型参数，对应着不同的类型检查和类型转换。也就是说，类不能根据类型参数的多少和顺序来区分，类型参数仅只是使用方式的概念。

 

顺便看一个例子。

可以看出，Integer.class是一个对象，它的类型应该为Class<Integer>或其子类，这里有了一个新概念，对象可以属于某种使用方式。

1.2.5.2. 通配符的类型限定

上面说了，类型参数的继承关系并不会传递给泛型类实例，这有点不符我们的思维习惯。为解决这个问题，引入了通配符。

<? extends Object>的代码形式叫做通配符的子类型限定，通常用作协变。还有通配符的超类型限定，代码形式是<? super Integer>，通常用作逆变。无限定的通配符为<?>。

 

关于通配符的用法如下。

public Method getMethod(String name, Class<?>... parameterTypes)
public static Class<?> forName(String className)
public native Class<? super T> getSuperclass()
Class<? super T> c = getSuperclass()
public <U> Class<? extends U> asSubclass(Class<U> clazz) {
return (Class<? extends U>) this
public <A extends Annotation> A getAnnotation(Class<A> annotationClass)
return (A) annotationData().annotations.get(annotationClass)

可以看出，通配符?可用于方法参数、方法返回、变量类型声明、变量强制转换等处，即?用在泛型类或泛型方法的使用上，而不用在泛型类的定义上。

 

Entry<Integer>在使用上来讲，是一个Entry<?>。这不是“is-a”的关系，因为“is-a”是静态的类与类的概念。这也不是泛型类实例间的关系，而只能是一种泛型类实例属于某个泛型类实例范围的概念，通配符?的类型限定表达的正是范围的概念。

1.2.5.3. 协变与逆变

下面的语法有问题。对编译器而言，list的类型参数可以是任何Object的子类（编译期根据声明而非实例化来确定），是不确定的，是一个范围，现在给确定的String于它显然不合适，因为list的类型参数可以是Integer等。

 

下面的就没有问题了。对编译器而言，list的类型参数可以是任何String的超类，也是不确定的，现在给确定的String于它却是合适的，因为list的类型参数虽然不确定，但一旦确定下来，它总是String的超类，可以接受String类型的值。

这里的list是用来添加元素的，对元素来说，它是消费者，因而有Consumer Super一说。完整的理解就是：对于被“吞进”的元素来说，list是消费者，为了完成“吞进”工作，它应该使用通配符的超类型限定。

 

然而，这样的使用了super的list就不能成为Producer了，即不能用来“吐出”元素。类似分析，即编译器认为list的类型参数可以是任何String的超类，是不确定的，现在用String来接纳它显然不合适，因为list的类型参数可以是Object。

 

解决的方法是，list又定义回使用extends，这就是Producer Extends一说的由来。

 

可以看到Producer Extends和Consumer Super是不能兼容的，只能二居其一，这就是PECS原则。总结一下就是：对于集合类，如果是只读的，则为Producer，使用extends，为协变，如果是只写的，则为Consumer，使用Super，为逆变，进一步简记为“协读PE，逆写CS”。

下面看个例子，Collections类同时使用了两者。

1.2.5.4. 空型泛型类实例

对Entry<T>来说，Entry有定义和使用两个方面的含义。作为定义泛型类的一面说，Entry被称为原始类型，作为使用泛型类的一面说，Entry等价于Entry<边界类型>，是确定的泛型类实例，不同于Entry<?>是一个泛型类实例范围，为了便于描述，不妨称它为空型泛型类实例，空型泛型类实例等价于边界类型的泛型类实例。比如下面的list1，乃是List<Object>，因而添加String是可以的。但list2是List<?>，可以是任何的类，现在给它赋值String，但它如果是List<Integer>就会出错。

 

再来看空型泛型类实例的字节码，处理是使用边界类型来的：

public class Demo {
    public static void main(String[] args) {
        List list1 = new ArrayList();
        list1.add("abc");
    }
}

 

再看下面的例子：

public class Entry<T extends Number> {
    private T value;

    public void setValue(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

Entry实际上等价于Entry<Number>，不等价于Entry<Object>，所以赋值String时出错。

1.2.6. 泛型使用的注意事项

1.2.6.1. 不能用基本类型来实例化类型参数

用则必须用它们的包装类。

这是因为，编译后类型参数被擦除，原始类中的类型变量（T）替换为Object，但Object类型不能存储基本类型的值。

1.2.6.2. 泛型类不能继承Throwable

但异常声明中可以使用类型参数。

1.2.6.3. 不能创建组件类型为参数化类型的数组

Object[]可以是任何数组的父类。

不能创建组件类型为参数化类型的数组，但可以声明。

Pair<String, String>[] pairs = (Pair<String, String>[]) new Pair[10]

1.2.6.4. 泛型类静态成员不可使用泛型类的类型参数

1.2.6.5. 其他

下面是可以的：

public class Demo {
    public static void main(String[] args) {
        Entry<String> entry = new Entry<String>();
        System.out.println(entry instanceof Entry<?>);
        System.out.println(entry instanceof Entry);
    }
}

但下面就不行：

entry instanceof Entry<String>

 

总结来看，注意事项能根据原理解释几个就行，不必刻意去掌握全了。多提一嘴，因为这些规则终究是编译器或JVM的代码逻辑：有的是绝对不能怎样的，有的则是一种可与不可的选择，甚至是编码者的一个临时随意，他这样要求而已，而有些甚至是其功能实现的副作用，对于这样的原因，需要了解编译后的字节码或者JVM代码才能弄清。但这不总是有必要的，因为即便是编码者本人，也许都不清楚，而且近乎全部的使用都不会触及副作用。总之，只要能用其精髓，分析懂别人代码，遇到错能分析就已经足够，除非自己要搞一套编译器或JVM，做得更好，或者发生了某种平台性的bug，则才细究另论。

1.3. 泛型的实现原理

1.3.1. 类型擦除

1.3.1.1. 定义泛型类时对应类型参数的地方都用边界类型

先看下面的类。

public class Pair<K extends Number, V> {
    private K key;
    private V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public void setKey(K key) {
        this.key = key;
    }

    public K getKey() {
        return key;
    }

    public void setValue(V value) {
        this.value = value;
    }

    public V getValue() {
        return value;
    }
}

 

编译器会将泛型类所有的对应类型参数的地方替换为边界类型，而泛型类本身对应到原始类型，它是泛型类使用时的模板，以得到最终的字节码文件。

编译后，构造方法的字节码如下：

可以看到，参数key被保存为边界类型Number，而参数value被保存为默认的边界类型Object。set方法与之类似。

 

编译后，getKey方法的字节码如下：

可以看到，字段存储使用的是Number类型，而方法描述符中返回类型也是Number。

1.3.1.2. 使用泛型类时使用类中会自动类型检查和强制转换

来看对泛型类的使用：

public class Demo {
    public static void main(String[] args) {
        Integer key = 5;
        String value = "hello world";
        Pair<Integer, String> pair = new Pair<Integer, String>(key, value);
        Integer i = pair.getKey();
    }
}

 

下面看main方法的字节码：

可以看到，在调用构造方法时，会把参数存为边界类型（set也类似）。在获取值时，自动加了一个类型转换指令，由Number转换为Integer。需要注意的是，如果编码时，构造方法参数或set方法参数类型不是实际类型的，则编译不过，因为编译器会作类型检查，如果编译通过，则还是通过边界类型存储，而不是实际类型。

 

总之，泛型类定义时，在字节码上只保留了原始类型和对边界类型的使用，当然也保留了它的类型参数标识。在泛型类使用时，编译器替我们完成了类型检查及强制转换的工作，不同目标类型的类型检查及强制转换，完成了不同动态类型的区别功能，因而动态类型就没有必要而被“擦除”了，因而这种泛型的实现机制被称为类型擦除。类型擦除也会发生于泛型方法中，如泛型方法public static <T extends Comparable> T min(T[] a)编译后会变成下面这样：public static Comparable min(Comparable[] a)。

 

因为Java泛型是通过类型擦除实现的，本质上是边界类型的继承多态实现的，而非每一个类型参数实例都对应一个类定义，因而是伪泛型。伪泛型的好处在于兼容了之前的继承多态版本（如早期Java的集合框架就是使用Object继承多态实现的，伪泛型便于保持向下兼容），也可以防止类型膨胀。泛型是继基类继承、接口实现后的有一种泛化机制。

1.3.1.3. 通过泛型的实现原理分析一个实例

下面的代码没有报错：

ArrayList的类型参数指定为Integer，加入1是自然的，而加入字符串未报错又是为何？这是因为ArrayList使用了反射语法，添加操作已经不在ArrayList类里发生，在编译期都识别不出这是add操作，因而编译期检查通过了。运行的时候，调用的是add(Object)，所以也没有问题。接下来，println方法需要的参数是Object，所以编译的字节码结果是arrayList.get(i)返回的是Object，没有强制类型转换操作。而最终打印出这个字符串，则是因为println一个Object的时候，通过invokevirtual指令调用了子类，即String类的重写toString方法。

 

但下面的报错了：

这是因为，虽然arrayList.get(i)获得的是Object，但马上的操作是getClass，编译器作了强制类型转换为实际的类型参数类型。原来通过Object类型保存的字符串，要转换为显式的Integer，就发生错误了。

1.3.2. 桥接方法

类型擦除会引入新问题。

 

看下面的类。

public class IntegerStringPair extends Pair<Integer, String> {
    public IntegerStringPair(Integer key, String value) {
        super(key, value);
    }

    @Override
    public void setValue(String value) {
        super.setValue(value);
    }
}

 

子类会从Pair类继承setValue方法，Pair类的这个方法如下：

可以看到这个方法的签名是public void setValue(Object)，而子类的签名是public void setValue(String)，即子类的本意是要覆写父类的该方法，但实际上变为了方法重载。

 

public class Demo {
    public static void main(String[] args) {
        Pair<Integer, String> pair = new IntegerStringPair(5, "hello world");
        pair.setValue("oh");
    }
}

此时，pair.setValue(“oh”)调用的是父类的setValue(Object)，因为发现子类没有覆写方法，所以调用到这里就结束了。这是违背动态调用指令invokevirtual和覆写语法的本意的。

 

为了弥补，编译器引入了桥接方法，即在子类中覆写从泛型继承来的方法（这是自动完成的，无需人工干预，下面的第二个setValue）：

pair.setValue(“oh”)调用的就是子类的这个setValue(Object)了，可以看到这个桥接方法转换类型后，又调用子类的setValue(String)，这样从外观效果上看pair.setValue(“oh”)调用了子类的setValue(String)，这正是“桥接”的意义所在。顺便说一句，子类setValue(String)里面的super.setValue(value)调用父类的setValue(Object)则是与此无关的方法自身的逻辑了。

1.4. 参考资料

http://www.importnew.com/24029.html

http://www.importnew.com/19740.html

http://blog.csdn.net/sunxianghuang/article/details/51982979

 

http://www.importnew.com/21694.html