Java泛型之PECS原则

最新推荐文章于 2025-03-18 14:01:33 发布

日向彻永垂不朽

最新推荐文章于 2025-03-18 14:01:33 发布

阅读量801

点赞数 2

分类专栏： Java基础文章标签：泛型 PECS

Java基础专栏收录该内容

7 篇文章

订阅专栏

本文深入解析Java泛型中通配符的使用，包括上界<?extendsT>和下界<?superT>的区别，以及它们在实际应用中的副作用。通过实例讲解如何正确使用泛型，避免类型安全问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

转载自：
【Java】泛型中 extends 和 super 的区别？
Java泛型详解

文章目录

通配符

public static void fun(List<?> list) {…}

上面代码中的“?”就是一个通配符，它只能在“<>”中使用。这时你可以向fun()方法传递List<String>、List<Integer>类型的参数了。当传递List<String>类型的参数时，表示给“?”赋值为String；当传递List<Integer>类型的参数给fun()方法时，表示给“?”赋值为Integer。
<? extends T>：是指 “上界通配符（Upper Bounds Wildcards）”
<? super T>：是指 “下界通配符（Lower Bounds Wildcards）”

在Java的泛型集合中，默认都可以添加null。除此之外，还有以下三条规则，这也是通配符的副作用。

"?"不能往里存，往外取只能放在Object对象里。
<? extends T>不能往里存，只能往外取。
<? super T>可以往里存，但往外取只能放在Object对象里。

下面主要介绍上下界通配符的副作用。

上下界通配符的副作用

边界让Java不同泛型之间的转换更容易了。但这样的转换也有一定的副作用。那就是容器的部分功能可能失效。

以Plate为例。我们可以对盘子做两件事，往盘子里set新东西，以及从盘子里get东西。

class Plate<T>{
    private T item;
    public Plate(T t){item=t;}
    public void set(T t){item=t;}
    public T get(){return item;}
}

上界<? extends T>不能往里存，只能往外取

<? extends Fruit>会使往盘子里放东西的set( )方法失效。但取东西get( )方法还有效。比如下面例子里两个set()方法，插入Apple和Fruit都报错。

Plate<? extends Fruit> p=new Plate<Apple>(new Apple());
	
//不能存入任何元素
p.set(new Fruit());    //Error
p.set(new Apple());    //Error

//读取出来的东西只能存放在Fruit或它的基类里。
Fruit newFruit1=p.get();
Object newFruit2=p.get();
Apple newFruit3=p.get();    //Error

原因是编译器只知道容器内是Fruit或Fruit的子类，但具体是什么类型不知道。可能是Fruit，可能是Apple，也可能是Banana，RedApple，GreenApple。编译器在看到后面用Plate赋值以后，盘子里没有被标上有“苹果”。而是标上一个占位符：CAP#1，来表示捕获一个Fruit或Fruit的子类，具体是什么类不知道，代号CAP#1。然后无论是想往里存储Apple，Meat或Fruit时编译器不知道能否和这个CAP#1匹配，所以就都不允许。

所以通配符<?>和类型参数T的区别就在于，对编译器来说所有的T都代表同一种类型。比如下面这个泛型方法里，三个T都指代同一个类型，要么都是String，要么都是Integer。

public <T> List<T> fill(T... t);

但通配符<?>没有这种约束，Plate<?>单纯的就表示：盘子里放了一个东西，具体是什么东西是不确定的。

下界<? super T>不影响往里存，但往外取只能放在Object对象里

使用下界<? super Fruit>会使从盘子里取东西的get( )方法部分失效，只能存放到Object对象里。set( )方法正常。

Plate<? super Fruit> p=new Plate<Fruit>(new Fruit());

//存入元素正常
p.set(new Fruit());
p.set(new Apple());

//读取出来的东西只能存放在Object类里。
Apple newFruit3=p.get();    //Error
Fruit newFruit1=p.get();    //Error
Object newFruit2=p.get();

因为下界规定了元素的最小粒度的下限，实际上是放松了容器元素的类型控制。既然元素是Fruit的父类，那往里存储粒度比Fruit小的都可以。但往外读取元素就费劲了，只有所有类的基类Object对象才能装下。但这样的话，元素的类型信息就全部丢失。

PECS原则

最后看一下什么是PECS（Producer Extends Consumer Super）原则，已经很好理解了：

根据上面的例子，我们可以总结出一条规律，”Producer Extends, Consumer Super”：

“Producer Extends” – 如果需要一个只读List，用它来produce T，那么使用? extends T。
“Consumer Super” – 如果需要一个只写List，用它来consume T，那么使用? super T。
如果需要同时读取以及写入，那么我们就不能使用通配符了。

如果阅读过一些Java集合类的源码，可以发现通常我们会将两者结合起来一起用，比如像下面这样：

public class Collections {
    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        for (int i=0; i<src.size(); i++)
            dest.set(i, src.get(i));
    }
}

对于src，只读；对于dest，只写。