泛型学习第一篇

1.泛型之擦拭法

泛型是一种类似”模板代码“的技术，不同语言的泛型实现方式不一定相同。

Java语言的泛型实现方式是擦拭法（Type Erasure）。

所谓擦拭法是指，虚拟机对泛型其实一无所知，所有的工作都是编译器做的。

例如，我们编写了一个泛型类Pair<T>，这是编译器看到的代码：

public class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

}

而虚拟机根本不知道泛型。这是虚拟机执行的代码：

public class Pair {

    private Object first;

    private Object last;

    public Pair(Object first, Object last) {

        this.first = first;

        this.last = last;

    }

    public Object getFirst() {

        return first;

    }

    public Object getLast() {

        return last;

    }

}

因此，Java使用擦拭法实现泛型，导致了：

  • 编译器把类型<T>视为Object；
  • 编译器根据<T>实现安全的强制转型。

使用泛型的时候，我们编写的代码也是编译器看到的代码：

Pair<String> p = new Pair<>("Hello", "world");

String first = p.getFirst();

String last = p.getLast();

而虚拟机执行的代码并没有泛型：

Pair p = new Pair("Hello", "world");

String first = (String) p.getFirst();

String last = (String) p.getLast();

所以，Java的泛型是由编译器在编译时实行的，编译器内部永远把所有类型T视为Object处理，但是，在需要转型的时候，编译器会根据T的类型自动为我们实行安全地强制转型。

了解了Java泛型的实现方式——擦拭法，我们就知道了Java泛型的局限：

局限一：<T>不能是基本类型，例如int，因为实际类型是Object，Object类型无法持有基本类型：

Pair<int> p = new Pair<>(1, 2); // compile error!

局限二：无法取得带泛型的Class。观察以下代码：

public class Main {

    public static void main(String\[\] args) {

    }

}

class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

}

因为T是Object，我们对Pair<String>和Pair<Integer>类型获取Class时，获取到的是同一个Class，也就是Pair类的Class。

换句话说，所有泛型实例，无论T的类型是什么，getClass()返回同一个Class实例，因为编译后它们全部都是Pair<Object>。

局限三：无法判断带泛型的类型：

Pair<Integer> p = new Pair<>(123, 456);

// Compile error:

if (p instanceof Pair<String>) {

}

原因和前面一样，并不存在Pair<String>.class，而是只有唯一的Pair.class。

局限四：不能实例化T类型：

public class Pair<T> {

    private T first;

    private T last;

    public Pair() {

        // Compile error:

        first = new T();

        last = new T();

    }

}

上述代码无法通过编译，因为构造方法的两行语句：

first = new T();

last = new T();

擦拭后实际上变成了：

first = new Object();

last = new Object();

这样一来，创建new Pair<String>()和创建new Pair<Integer>()就全部成了Object，显然编译器要阻止这种类型不对的代码。

要实例化T类型，我们必须借助额外的Class<T>参数：

public class Pair<T> {

    private T first;

    private T last;

    public Pair(Class<T> clazz) {

        first = clazz.newInstance();

        last = clazz.newInstance();

    }

}

上述代码借助Class<T>参数并通过反射来实例化T类型，使用的时候，也必须传入Class<T>。例如：

Pair<String> pair = new Pair<>(String.class);

因为传入了Class<String>的实例，所以我们借助String.class就可以实例化String类型。

不恰当的覆写方法

有些时候，一个看似正确定义的方法会无法通过编译。例如：

public class Pair<T> {

    public boolean equals(T t) {

        return this == t;

    }

}

这是因为，定义的equals(T t)方法实际上会被擦拭成equals(Object t)，而这个方法是继承自Object的，编译器会阻止一个实际上会变成覆写的泛型方法定义。

换个方法名，避开与Object.equals(Object)的冲突就可以成功编译：

public class Pair<T> {

    public boolean same(T t) {

        return this == t;

    }

}

泛型继承

一个类可以继承自一个泛型类。例如：父类的类型是Pair<Integer>，子类的类型是IntPair，可以这么继承：

public class IntPair extends Pair<Integer> {

}

使用的时候，因为子类IntPair并没有泛型类型，所以，正常使用即可：

IntPair ip = new IntPair(1, 2);

前面讲了，我们无法获取Pair<T>的T类型，即给定一个变量Pair<Integer> p，无法从p中获取到Integer类型。

但是，在父类是泛型类型的情况下，编译器就必须把类型T（对IntPair来说，也就是Integer类型）保存到子类的class文件中，不然编译器就不知道IntPair只能存取Integer这种类型。

在继承了泛型类型的情况下，子类可以获取父类的泛型类型。例如：IntPair可以获取到父类的泛型类型Integer。获取父类的泛型类型代码比较复杂：

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

public class Main {

    public static void main(String\[\] args) {

    }

}

class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

}

class IntPair extends Pair<Integer> {

    public IntPair(Integer first, Integer last) {

        super(first, last);

    }

}

因为Java引入了泛型，所以，只用Class来标识类型已经不够了。实际上，Java的类型系统结构如下：

                      ┌────┐

                      │Type│

                      └────┘

                         ▲

                         │

   ┌────────────┬────────┴─────────┬───────────────┐

   │            │                  │               │

┌─────┐┌─────────────────┐┌────────────────┐┌────────────┐

│Class││ParameterizedType││GenericArrayType││WildcardType│

└─────┘└─────────────────┘└────────────────┘└────────────┘

小结

Java的泛型是采用擦拭法实现的；

擦拭法决定了泛型<T>：

  • 不能是基本类型，例如：int；
  • 不能获取带泛型类型的Class，例如：Pair<String>.class；
  • 不能判断带泛型类型的类型，例如：x instanceof Pair<String>；
  • 不能实例化T类型，例如：new T()。

泛型方法要防止重复定义方法，例如：public boolean equals(T obj)；

子类可以获取父类的泛型类型<T>。

2.extends通配符

我们前面已经讲到了泛型的继承关系：Pair<Integer>不是Pair<Number>的子类。

假设我们定义了Pair<T>：

public class Pair<T> { ... }

然后，我们又针对Pair<Number>类型写了一个静态方法，它接收的参数类型是Pair<Number>：

public class PairHelper {

    static int add(Pair<Number> p) {

        Number first = p.getFirst();

        Number last = p.getLast();

        return first.intValue() + last.intValue();

    }

}

上述代码是可以正常编译的。使用的时候，我们传入：

int sum = PairHelper.add(new Pair<Number>(1, 2));

注意：传入的类型是Pair<Number>，实际参数类型是(Integer, Integer)。

既然实际参数是Integer类型，试试传入Pair<Integer>：

public class Main {

}

class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

}

直接运行，会得到一个编译错误：

incompatible types: Pair<Integer> cannot be converted to Pair<Number>

原因很明显，因为Pair<Integer>不是Pair<Number>的子类，因此，add(Pair<Number>)不接受参数类型Pair<Integer>。

但是从add()方法的代码可知，传入Pair<Integer>是完全符合内部代码的类型规范，因为语句：

Number first = p.getFirst();

Number last = p.getLast();

实际类型是Integer，引用类型是Number，没有问题。问题在于方法参数类型定死了只能传入Pair<Number>。

有没有办法使得方法参数接受Pair<Integer>？办法是有的，这就是使用Pair<? extends Number>使得方法接收所有泛型类型为Number或Number子类的Pair类型。我们把代码改写如下：

public class Main {

}

class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

}

这样一来，给方法传入Pair<Integer>类型时，它符合参数Pair<? extends Number>类型。这种使用<? extends Number>的泛型定义称之为上界通配符（Upper Bounds Wildcards），即把泛型类型T的上界限定在Number了。

除了可以传入Pair<Integer>类型，我们还可以传入Pair<Double>类型，Pair<BigDecimal>类型等等，因为Double和BigDecimal都是Number的子类。

如果我们考察对Pair<? extends Number>类型调用getFirst()方法，实际的方法签名变成了：

<? extends Number> getFirst();

即返回值是Number或Number的子类，因此，可以安全赋值给Number类型的变量：

Number x = p.getFirst();

然后，我们不可预测实际类型就是Integer，例如，下面的代码是无法通过编译的：

Integer x = p.getFirst();

这是因为实际的返回类型可能是Integer，也可能是Double或者其他类型，编译器只能确定类型一定是Number的子类（包括Number类型本身），但具体类型无法确定。

我们再来考察一下Pair<T>的set方法：

public class Main {

}

class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

    public void setFirst(T first) {

        this.first = first;

    }

    public void setLast(T last) {

        this.last = last;

    }

}

不出意外，我们会得到一个编译错误：

incompatible types: Integer cannot be converted to CAP#1

where CAP#1 is a fresh type-variable:

    CAP#1 extends Number from capture of ? extends Number

编译错误发生在p.setFirst()传入的参数是Integer类型。有些童鞋会问了，既然p的定义是Pair<? extends Number>，那么setFirst(? extends Number)为什么不能传入Integer？

原因还在于擦拭法。如果我们传入的p是Pair<Double>，显然它满足参数定义Pair<? extends Number>，然而，Pair<Double>的setFirst()显然无法接受Integer类型。

这就是<? extends Number>通配符的一个重要限制：方法参数签名setFirst(? extends Number)无法传递任何Number的子类型给setFirst(? extends Number)。

这里唯一的例外是可以给方法参数传入null：

p.setFirst(null); // ok, 但是后面会抛出NullPointerException

p.getFirst().intValue(); // NullPointerException

extends通配符的作用

如果我们考察Java标准库的java.util.List<T>接口，它实现的是一个类似“可变数组”的列表，主要功能包括：

public interface List<T> {

    int size(); // 获取个数

    T get(int index); // 根据索引获取指定元素

    void add(T t); // 添加一个新元素

    void remove(T t); // 删除一个已有元素

}

现在，让我们定义一个方法来处理列表的每个元素：

int sumOfList(List<? extends Integer> list) {

    int sum = 0;

    for (int i=0; i<list.size(); i++) {

        Integer n = list.get(i);

        sum = sum + n;

    }

    return sum;

}

为什么我们定义的方法参数类型是List<? extends Integer>而不是List<Integer>？从方法内部代码看，传入List<? extends Integer>或者List<Integer>是完全一样的，但是，注意到List<? extends Integer>的限制：

  • 允许调用get()方法获取Integer的引用；
  • 不允许调用set(? extends Integer)方法并传入任何Integer的引用（null除外）。

因此，方法参数类型List<? extends Integer>表明了该方法内部只会读取List的元素，不会修改List的元素（因为无法调用add(? extends Integer)、remove(? extends Integer)这些方法。换句话说，这是一个对参数List<? extends Integer>进行只读的方法（恶意调用set(null)除外）。

使用extends限定T类型

在定义泛型类型Pair<T>的时候，也可以使用extends通配符来限定T的类型：

public class Pair<T extends Number> { ... }

现在，我们只能定义：

Pair<Number> p1 = null;

Pair<Integer> p2 = new Pair<>(1, 2);

Pair<Double> p3 = null;

因为Number、Integer和Double都符合<T extends Number>。

非Number类型将无法通过编译：

Pair<String> p1 = null; // compile error!

Pair<Object> p2 = null; // compile error!

因为String、Object都不符合<T extends Number>，因为它们不是Number类型或Number的子类。

小结

使用类似<? extends Number>通配符作为方法参数时表示：

  • 方法内部可以调用获取Number引用的方法，例如：Number n = obj.getFirst();；

  • 方法内部无法调用传入Number引用的方法（null除外），例如：obj.setFirst(Number n);。

即一句话总结：使用extends通配符表示可以读，不能写。

使用类似<T extends Number>定义泛型类时表示：

  • 泛型类型限定为Number以及Number的子类。

super通配符

我们前面已经讲到了泛型的继承关系：Pair<Integer>不是Pair<Number>的子类。

考察下面的set方法：

void set(Pair<Integer> p, Integer first, Integer last) {

    p.setFirst(first);

    p.setLast(last);

}

传入Pair<Integer>是允许的，但是传入Pair<Number>是不允许的。

和extends通配符相反，这次，我们希望接受Pair<Integer>类型，以及Pair<Number>、Pair<Object>，因为Number和Object是Integer的父类，setFirst(Number)和setFirst(Object)实际上允许接受Integer类型。

我们使用super通配符来改写这个方法：

void set(Pair<? super Integer> p, Integer first, Integer last) {

    p.setFirst(first);

    p.setLast(last);

}

注意到Pair<? super Integer>表示，方法参数接受所有泛型类型为Integer或Integer父类的Pair类型。

下面的代码可以被正常编译：

public class Main {

}

class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

    public void setFirst(T first) {

        this.first = first;

    }

    public void setLast(T last) {

        this.last = last;

    }

}

考察Pair<? super Integer>的setFirst()方法，它的方法签名实际上是：

void setFirst(? super Integer);

因此，可以安全地传入Integer类型。

再考察Pair<? super Integer>的getFirst()方法，它的方法签名实际上是：

? super Integer getFirst();

这里注意到我们无法使用Integer类型来接收getFirst()的返回值，即下面的语句将无法通过编译：

Integer x = p.getFirst();

因为如果传入的实际类型是Pair<Number>，编译器无法将Number类型转型为Integer。

注意：虽然Number是一个抽象类，我们无法直接实例化它。但是，即便Number不是抽象类，这里仍然无法通过编译。此外，传入Pair<Object>类型时，编译器也无法将Object类型转型为Integer。

唯一可以接收getFirst()方法返回值的是Object类型：

Object obj = p.getFirst();

因此，使用<? super Integer>通配符表示：

  • 允许调用set(? super Integer)方法传入Integer的引用；

  • 不允许调用get()方法获得Integer的引用。

唯一例外是可以获取Object的引用：Object o = p.getFirst()。

换句话说，使用<? super Integer>通配符作为方法参数，表示方法内部代码对于参数只能写，不能读。

对比extends和super通配符

我们再回顾一下extends通配符。作为方法参数，<? extends T>类型和<? super T>类型的区别在于：

  • <? extends T>允许调用读方法T get()获取T的引用，但不允许调用写方法set(T)传入T的引用（传入null除外）；

  • <? super T>允许调用写方法set(T)传入T的引用，但不允许调用读方法T get()获取T的引用（获取Object除外）。

一个是允许读不允许写，另一个是允许写不允许读。

先记住上面的结论，我们来看Java标准库的Collections类定义的copy()方法：

public class Collections {

    // 把src的每个元素复制到dest中:

    public static <T> void copy(List<? super T> dest, List<? extends T> src) {

        for (int i=0; i<src.size(); i++) {

            T t = src.get(i);

            dest.add(t);

        }

    }

}

它的作用是把一个List的每个元素依次添加到另一个List中。它的第一个参数是List<? super T>，表示目标List，第二个参数List<? extends T>，表示要复制的List。我们可以简单地用for循环实现复制。在for循环中，我们可以看到，对于类型<? extends T>的变量src，我们可以安全地获取类型T的引用，而对于类型<? super T>的变量dest，我们可以安全地传入T的引用。

这个copy()方法的定义就完美地展示了extends和super的意图：

  • copy()方法内部不会读取dest，因为不能调用dest.get()来获取T的引用；

  • copy()方法内部也不会修改src，因为不能调用src.add(T)。

这是由编译器检查来实现的。如果在方法代码中意外修改了src，或者意外读取了dest，就会导致一个编译错误：

public class Collections {

    // 把src的每个元素复制到dest中:

    public static <T> void copy(List<? super T> dest, List<? extends T> src) {

        ...

        T t = dest.get(0); // compile error!

        src.add(t); // compile error!

    }

}

这个copy()方法的另一个好处是可以安全地把一个List<Integer>添加到List<Number>，但是无法反过来添加：

// copy List<Integer> to List<Number> ok:

List<Number> numList = ...;

List<Integer> intList = ...;

Collections.copy(numList, intList);

// ERROR: cannot copy List<Number> to List<Integer>:

Collections.copy(intList, numList);

而这些都是通过super和extends通配符，并由编译器强制检查来实现的。

PECS原则

何时使用extends，何时使用super？为了便于记忆，我们可以用PECS原则：Producer Extends Consumer Super。

即：如果需要返回T，它是生产者（Producer），要使用extends通配符；如果需要写入T，它是消费者（Consumer），要使用super通配符。

还是以Collections的copy()方法为例：

public class Collections {

    public static <T> void copy(List<? super T> dest, List<? extends T> src) {

        for (int i=0; i<src.size(); i++) {

            T t = src.get(i); // src是producer

            dest.add(t); // dest是consumer

        }

    }

}

需要返回T的src是生产者，因此声明为List<? extends T>，需要写入T的dest是消费者，因此声明为List<? super T>。

无限定通配符

我们已经讨论了<? extends T>和<? super T>作为方法参数的作用。实际上，Java的泛型还允许使用无限定通配符（Unbounded Wildcard Type），即只定义一个?：

void sample(Pair<?> p) {

}

因为<?>通配符既没有extends，也没有super，因此：

  • 不允许调用set(T)方法并传入引用（null除外）；
  • 不允许调用T get()方法并获取T引用（只能获取Object引用）。

换句话说，既不能读，也不能写，那只能做一些null判断：

static boolean isNull(Pair<?> p) {

    return p.getFirst() == null || p.getLast() == null;

}

大多数情况下，可以引入泛型参数<T>消除<?>通配符：

static <T> boolean isNull(Pair<T> p) {

    return p.getFirst() == null || p.getLast() == null;

}

<?>通配符有一个独特的特点，就是：Pair<?>是所有Pair<T>的超类：

public class Main {

}

class Pair<T> {

    private T first;

    private T last;

    public Pair(T first, T last) {

        this.first = first;

        this.last = last;

    }

    public T getFirst() {

        return first;

    }

    public T getLast() {

        return last;

    }

    public void setFirst(T first) {

        this.first = first;

    }

    public void setLast(T last) {

        this.last = last;

    }

}

上述代码是可以正常编译运行的，因为Pair<Integer>是Pair<?>的子类，可以安全地向上转型。

小结

使用类似<? super Integer>通配符作为方法参数时表示：

  • 方法内部可以调用传入Integer引用的方法，例如：obj.setFirst(Integer n);；

  • 方法内部无法调用获取Integer引用的方法（Object除外），例如：Integer n = obj.getFirst();。

即使用super通配符表示只能写不能读。

使用extends和super通配符要遵循PECS原则。

无限定通配符<?>很少使用，可以用<T>替换，同时它是所有<T>类型的超类。

最新文章

  1. 4、python列表
  2. sybase ODBC驱动
  3. Moon.Orm 5.0 (MQL版) 实战实例
  4. Criterion &amp; DetachedCriteria
  5. SVMtoy
  6. HDU 1428 漫步校园（记忆化搜索，BFS， DFS）
  7. ubuntn14.04 32位安装hadoop2.7.2
  8. 在Yii框架中使用PHPExcel
  9. 远程控制编写之屏幕传输 MFC实现 屏幕截图 发送bmp数据 显示bmp图像
  10. Notepad++中过滤掉的正则方式
  11. AI 新技术革命将如何重塑就业和全球化格局？深度解读 UN 报告（上篇）
  12. 基于RabbitMQ.Client组件实现RabbitMQ可复用的 ConnectionPool（连接池）
  13. Android版本更新时对SQLite数据库升级或者降级遇到的问题
  14. puppeteer（三）常用API
  15. JDK（java development kit java开发工具包）的安装
  16. ssh 管理 linux登录远程服务器
  17. eclipse中安装maven，配置本地仓库和镜像
  18. centos6.5最小化安装之后装图形化界面
  19. windows中使用git和开源中国
  20. excel如何快速实现数据区域的框选

热门文章

  1. 关于echarts中的noDataLoadingOption——loading动画的问题
  2. Redis必知必会系列
  3. #3使用html+css+js制作网页 番外篇 使用python flask 框架 (I)
  4. 【函数分享】每日PHP函数分享(2021-1-11)
  5. OpenTelemetry - 云原生下可观测性的新标准
  6. 【Java基础】基本语法-变量与运算符
  7. LeetCode167 两数之和 II - 输入有序数组
  8. （十九）hashlib模块
  9. kubernets之控制器之间的协作以及网络
  10. DOS的FOR命令用法总结