• 【Java】泛型 之 super通配符

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

    考察下面的set方法：

    void set(Pair<Integer> p, Integer first, Integer last) {
    p.setFirst(first);
    p.setLast(last);
}

    • 1
    • 2
    • 3
    • 4

    传入Pair是允许的，但是传入Pair是不允许的。

    和extends通配符相反，这次，我们希望接受Pair类型，以及Pair、Pair，因为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);
}

    • 1
    • 2
    • 3
    • 4

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

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

    public class Main {
    public static void main(String[] args) {
        Pair<Number> p1 = new Pair<>(12.3, 4.56);
        Pair<Integer> p2 = new Pair<>(123, 456);
        setSame(p1, 100);
        setSame(p2, 200);
        System.out.println(p1.getFirst() + ", " + p1.getLast());
        System.out.println(p2.getFirst() + ", " + p2.getLast());
    }

    static void setSame(Pair<? super Integer> p, Integer n) {
        p.setFirst(n);
        p.setLast(n);
    }

}

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    考察Pair的setFirst()方法，它的方法签名实际上是：

    void setFirst(? super Integer);
    因此，可以安全地传入Integer类型。

    再考察Pair的getFirst()方法，它的方法签名实际上是：

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

    Integer x = p.getFirst();
    因为如果传入的实际类型是Pair，编译器无法将Number类型转型为Integer。

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

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

    Object obj = p.getFirst();
    因此，使用通配符表示：

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

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

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

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

    对比extends和super通配符

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

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

    允许调用写方法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);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    它的作用是把一个List的每个元素依次添加到另一个List中。它的第一个参数是List，表示目标List，第二个参数List，表示要复制的List。我们可以简单地用for循环实现复制。在for循环中，我们可以看到，对于类型的变量src，我们可以安全地获取类型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!
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

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

    // copy List to List ok:
List<Number> numList = ...;
List<Integer> intList = ...;
Collections.copy(numList, intList);

// ERROR: cannot copy List to List:
Collections.copy(intList, numList);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    而这些都是通过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
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

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

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

    void sample(Pair<?> p) {
}

    • 1
    • 2

    因为通配符既没有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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

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

    public class Main {
    public static void main(String[] args) {
        Pair<Integer> p = new Pair<>(123, 456);
        Pair<?> p2 = p; // 安全地向上转型
        System.out.println(p2.getFirst() + ", " + p2.getLast());
    }

}

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

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

    小结

    使用类似通配符作为方法参数时表示：

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

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

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

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

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

  • 相关阅读:
    《深入解析阿里电商：数据中台与业务的双中台系统架构》
    小赢科技，寻找金融科技核心价
    时间序列问题案例分析Kaggle M5 Forecasting
    漏洞复现 - - - WebLogic反序列化远程命令执行漏洞（二）
    Arcgis提取点数据经纬度
    python爬取b站弹幕可视化词云图问题
    金仓数据库KingbaseES数据库参考手册(服务器配置参数6. 预写式日志)
    duilib 实现登录界面 之 样式设计
    1004 Counting Leaves
    GBase 8d的特性-可扩展性
  • 原文地址：https://blog.csdn.net/ihero/article/details/133276180