什么时候使用泛型方法，什么时候使用通配符？

Posted

技术标签:

【中文标题】什么时候使用泛型方法，什么时候使用通配符？【英文标题】：When to use generic methods and when to use wild-card? 【发布时间】：2022-01-20 02:37:43 【问题描述】：

我正在阅读来自OracleDocGenericMethod 的泛型方法。当它说何时使用通配符以及何时使用泛型方法时，我对比较感到非常困惑。 引用自文档。

interface Collection<E> 
    public boolean containsAll(Collection<?> c);
    public boolean addAll(Collection<? extends E> c);

我们可以在这里使用泛型方法：

interface Collection<E> 
    public <T> boolean containsAll(Collection<T> c);
    public <T extends E> boolean addAll(Collection<T> c);
    // Hey, type variables can have bounds too!

[…] 这告诉我们类型参数被用于多态性； 它的唯一作用是允许各种实际参数类型 在不同的调用站点使用。如果是这种情况，应该 使用通配符。通配符旨在支持灵活的子类型化， 这就是我们在这里想要表达的。

我们不认为像(Collection&lt;? extends E&gt; c); 这样的通配符也支持某种 多态性？那为什么泛型方法的使用在这方面被认为不好呢？

它指出，继续前进，

泛型方法允许使用类型参数来表达 方法的一个或多个参数类型之间的依赖关系 和/或其返回类型。如果没有这样的依赖，一个泛型 方法不应该使用。

这是什么意思？

他们已经给出了例子

class Collections 
    public static <T> void copy(List<T> dest, List<? extends T> src) 
    ...

[…]

我们可以用另一种方式为这个方法写签名， 完全不使用通配符：

class Collections 
    public static <T, S extends T> void copy(List<T> dest, List<S> src) 
    ...

该文件不鼓励使用第二个声明并提倡使用第一个语法？第一次和第二次声明有什么区别？两者似乎都在做同样的事情？

谁能照亮这个区域。

【问题讨论】：

【参考方案1】：

?表示未知

一般规则适用： 您可以从中读取，但不能写入

给定简单的 pojo 汽车

class Car 
    void display()

这将编译

private static <T extends Car> void addExtractedAgain1(List<T> cars) 
    T t = cars.get(1);
    t.display();
    cars.add(t);

这个方法不会编译

private static void addExtractedAgain2(List<? extends Car> cars) 
    Car car = cars.get(1);
    car.display();
    cars.add(car); // will not compile

另一个例子

List<?> hi = Arrays.asList("Hi", new Exception(), 0);

hi.forEach(o -> 
   o.toString() // it's ok to call Object methods and methods that don't need the contained type
);

hi.add(...) // nothing can be add here won't compile, we need to tell compiler what the data type is but we do not know

【讨论】：

【参考方案2】：

主要 -> 通配符在非泛型方法的参数/参数级别强制泛型。 笔记。默认情况下也可以在 genericMethod 中执行，但这里不是 ?我们可以使用 T 本身。

包泛型；

public class DemoWildCard 


    public static void main(String[] args) 
        DemoWildCard obj = new DemoWildCard();

        obj.display(new Person<Integer>());
        obj.display(new Person<String>());

    

    void display(Person<?> person) 
        //allows person of Integer,String or anything
        //This cannnot be done if we use T, because in that case we have to make this method itself generic
        System.out.println(person);
    



class Person<T>

SO 通配符有类似这样的特定用例。

【讨论】：

【参考方案3】：

据我了解，只有一个用例是严格需要通配符（即可以表达一些使用显式类型参数无法表达的东西）。这是您需要指定下限的时候。

除此之外，通配符还可以编写更简洁的代码，如您提到的文档中的以下语句所述：

泛型方法允许使用类型参数来表达 方法的一个或多个参数类型之间的依赖关系 和/或其返回类型。如果没有这样的依赖，一个泛型 方法不应该使用。

[...]

使用通配符比显式声明更清晰、更简洁 类型参数，因此应尽可能首选。

[...]

通配符还有一个优点是可以在外面使用 方法签名，如字段、局部变量和数组的类型。

【讨论】：

【参考方案4】：

这里没有列出的另一个区别。 

static <T> void fromArrayToCollection(T[] a, Collection<T> c) 
    for (T o : a) 
        c.add(o); // correct

但是下面会导致编译时出错。

static <T> void fromArrayToCollection(T[] a, Collection<?> c) 
    for (T o : a) 
        c.add(o); // compile time error

【讨论】：

【参考方案5】：

在您的第一个问题中：这意味着如果参数类型和方法的返回类型之间存在关系，则使用泛型。

例如：

public <T> T giveMeMaximum(Collection<T> items);
public <T> Collection<T> applyFilter(Collection<T> items);

在这里，您正在按照特定标准提取一些 T。如果 T 是 Long 你的方法将返回 Long 和 Collection&lt;Long&gt;;实际的返回类型取决于参数类型，因此建议使用泛型类型。

如果不是这种情况，您可以使用通配符类型：

public int count(Collection<?> items);
public boolean containsDuplicate(Collection<?> items);

在这两个示例中，无论集合中项目的类型如何，返回类型都是int 和boolean。

在你的例子中：

interface Collection<E> 
    public boolean containsAll(Collection<?> c);
    public boolean addAll(Collection<? extends E> c);

这两个函数将返回一个布尔值，无论集合中项目的类型是什么。在第二种情况下，它仅限于 E 的子类的实例。

第二个问题：

class Collections 
    public static <T> void copy(List<T> dest, List<? extends T> src) 
    ...

第一个代码允许您将异构List&lt;? extends T&gt; src 作为参数传递。这个列表可以包含多个不同类的元素，只要它们都扩展了基类 T。

如果你有：

interface Fruit

和

class Apple implements Fruit
class Pear implements Fruit
class Tomato implements Fruit

你可以的

List<? extends Fruit> basket = new ArrayList<? extends Fruit>();
basket.add(new Apple());
basket.add(new Pear());
basket.add(new Tomato());
List<Fruit> fridge = new ArrayList<Fruit>(); 

Collections.copy(fridge, basket);// works

另一方面

class Collections 
    public static <T, S extends T> void copy(List<T> dest, List<S> src) 
    ...

将List&lt;S&gt; src 约束为一个特定的类 S，它是 T 的子类。列表只能包含一个类（在此实例中为 S）的元素，而不能包含其他类的元素，即使它们也实现了 T。您将无法使用我之前的示例，但您可以这样做：

List<Apple> basket = new ArrayList<Apple>();
basket.add(new Apple());
basket.add(new Apple());
basket.add(new Apple());
List<Fruit> fridge = new ArrayList<Fruit>();

Collections.copy(fridge, basket); /* works since the basket is defined as a List of apples and not a list of some fruits. */

【讨论】：

List&lt;? extends Fruit&gt; basket = new ArrayList&lt;? extends Fruit&gt;(); 不是有效的语法。您必须无限制地实例化 ArrayList。 无法将苹果添加到上例中的篮子，因为篮子可能是梨的列表。不正确的示例 AFAIK。而且也不能编译。 @ArnoldPistorius 这让我很困惑。我检查了 ArrayList 的 API 文档，它有一个签名为 ArrayList(Collection&lt;? extends E&gt; c) 的构造函数。你能解释一下你为什么这么说吗？ @Kurapika 可能是我使用的是旧的 Java 版本？评论是在大约 3 年前发布的。【参考方案6】：

考虑以下詹姆斯·高斯林 (James Gosling) 第 4 版的 Java 编程示例，我们要在其中合并 2 个 SinglyLinkQueue：

public static <T1, T2 extends T1> void merge(SinglyLinkQueue<T1> d, SinglyLinkQueue<T2> s)
    // merge s element into d


public static <T> void merge(SinglyLinkQueue<T> d, SinglyLinkQueue<? extends T> s)
        // merge s element into d

上述两种方法具有相同的功能。那么哪个更可取？答案是第2个。用作者自己的话来说：

“一般规则是尽可能使用通配符，因为使用通配符的代码 通常比具有多个类型参数的代码更具可读性。在决定是否需要类型时 变量，问问自己该类型变量是否用于关联两个或多个参数，或者关联一个参数 类型与返回类型。如果答案是否定的，那么通配符就足够了。”

注意：书中只给出了第二种方法，类型参数名称是 S 而不是 'T'。第一种方法书中没有。

【讨论】：

我投了一本书的引用，它直接而简洁【参考方案7】：

在某些地方，通配符和类型参数做同样的事情。但也有一些地方，你必须使用类型参数。

    如果你想对不同类型的方法参数强制执行某种关系，你不能用通配符来做到这一点，你必须使用类型参数。

以您的方法为例，假设您要确保传递给copy() 方法的src 和dest 列表应该是相同的参数化类型，您可以像这样使用类型参数：

public static <T extends Number> void copy(List<T> dest, List<T> src)

在这里，您可以确保dest 和src 具有相同的List 参数化类型。因此，将元素从src 复制到dest 是安全的。

但是，如果你继续改变使用通配符的方法：

public static void copy(List<? extends Number> dest, List<? extends Number> src)

它不会按预期工作。在第二种情况下，您可以将List&lt;Integer&gt; 和List&lt;Float&gt; 传递为dest 和src。因此，将元素从 src 移动到 dest 将不再是类型安全的。 如果你不需要这种关系，那么你完全可以不使用类型参数。

使用通配符和类型参数之间的其他一些区别是：

如果您只有一个参数化类型参数，则可以使用通配符，尽管类型参数也可以。 类型参数支持多个边界，通配符不支持。

通配符同时支持上限和下限，类型参数只支持上限。因此，如果您想定义一个采用 List 类型为 Integer 或其超类的方法，您可以这样做：

public void print(List<? super Integer> list)  // OK

但你不能使用类型参数：

 public <T super Integer> void print(List<T> list)  // Won't compile

参考资料：

Angelika Langer's Java Generics FAQs

【讨论】：

这是一个奇怪的答案。它根本没有解释为什么你需要使用?。您可以将其重写为 `public static void copy(List dest, List src) ，在这种情况下很明显发生了什么。 @kan。嗯，这才是真正的问题。您可以使用类型参数来强制执行相同的类型，但不能使用通配符来执行此操作。对类型参数使用两种不同的类型是不同的事情。 @benz。您不能使用类型参数在 List 中定义下限。 List&lt;T super Integer&gt; 无效，不会编译。 @benz。不客气:) 我强烈建议您浏览我最后发布的链接。这是你能得到的关于泛型的最佳资源。 @jorgen.ringen &lt;T extends X &amp; Y&gt; -> 多个边界。【参考方案8】：

我会尝试一一回答你的问题。

我们不认为像(Collection&lt;? extends E&gt; c); 这样的通配符也是 支持某种多态性？

没有。原因是有界通配符没有定义参数类型。这是一个未知数。它“知道”的只是“遏制”是E 类型（无论定义什么）。因此，它无法验证和证明提供的值是否与有界类型匹配。

因此，在通配符上使用多态行为是不明智的。

该文件不鼓励第二次声明并提倡使用 第一种语法？第一和第二有什么区别 宣言？两者似乎都在做同样的事情？

在这种情况下，第一个选项更好，因为T 始终是有界的，并且source 肯定会有（未知的）值是T 的子类。

因此，假设您要复制所有数字列表，第一个选项将是

Collections.copy(List<Number> dest, List<? extends Number> src);

src 基本上可以接受List&lt;Double&gt;、List&lt;Float&gt; 等，因为dest 中的参数化类型有一个上限。

第二个选项将强制您为要复制的每种类型绑定S，就像这样

//For double 
Collections.copy(List<Number> dest, List<Double> src); //Double extends Number.

//For int
Collections.copy(List<Number> dest, List<Integer> src); //Integer extends Number.

由于S 是需要绑定的参数化类型。

我希望这会有所帮助。

【讨论】：

你能解释一下你最后一段的意思吗 说明第二个选项的那个会强制你绑定一个......你能详细说明一下吗 &lt;S extends T&gt; 声明S 是T 的子类的参数化类型，因此它需要作为T 子类的参数化类型（无通配符）。跨度> 【参考方案9】：

通配符方法也是通用的——你可以用一些类型来调用它。

&lt;T&gt; 语法定义了一个类型变量名。如果一个类型变量有任何用途（例如，在方法实现中或作为其他类型的约束），那么命名它是有意义的，否则你可以使用?，作为匿名变量。所以，看起来只是一个捷径。

此外，在声明字段时，? 语法是不可避免的：

class NumberContainer

 Set<? extends Number> numbers;

【讨论】：

这不应该是评论吗？ @BuhakeSindi 抱歉，有什么不清楚的地方？为什么是-1？我认为它回答了这个问题。

以上是关于什么时候使用泛型方法，什么时候使用通配符？的主要内容，如果未能解决你的问题，请参考以下文章

Java泛型使用的简单介绍

java泛型与通配符

泛型通配符规则

Java重点--泛型

你了解泛型通配符与上下界吗？

你了解泛型通配符与上下界吗？