143

我正在阅读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<? extends E> 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) {
    ...
}

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

有人可以照亮这个区域吗？

4

9 回答 9

200

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

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

以您的方法为例，假设您要确保传递给方法的srcand列表应该是相同的参数化类型，您可以使用如下类型参数来做到这一点：destcopy()

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<Integer>andList<Float>作为destand src。因此，将元素从srcto移动dest不再是类型安全的。如果您不需要这种关系，那么您可以完全不使用类型参数。

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

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

  • 通配符同时支持上限和下限，类型参数只支持上限。因此，如果您想定义一个采用Listof 类型Integer或其超类的方法，您可以执行以下操作：

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

    但你不能使用类型参数：

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

参考：

于 2013-08-11T21:16:54.040 回答
23

考虑以下来自 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'。书中没有第一种方法。

于 2015-07-19T00:37:45.677 回答
12

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

例如：

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

在这里，您正在按照特定标准提取一些 T。如果 T 是Long您的方法将返回Longand Collection<Long>; 实际的返回类型取决于参数类型，因此使用泛型类型很有用，并且建议使用。

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

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<? extends T> 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<S> 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. */
于 2013-08-11T21:21:48.727 回答
4

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

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

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

class NumberContainer
{
 Set<? extends Number> numbers;
}
于 2013-08-11T21:07:12.743 回答
3

我将尝试一一回答您的问题。

难道我们不认为通配符之类(Collection<? extends E> c);的也支持某种多态性吗？

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

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

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

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

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

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

src，本质上，可以接受List<Double>,List<Float>等，因为在 中找到的参数化类型有一个上限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.

AsS是需要绑定的参数化类型。

我希望这有帮助。

于 2013-08-11T21:26:56.970 回答
2

此处未列出的另一个区别。

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
    }
}
于 2017-08-01T02:43:26.617 回答
1

? 意味着未知

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

给定简单的 pojo Car

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
于 2020-08-25T16:12:15.667 回答
0

主要 -> 通配符在非泛型方法的参数/参数级别强制泛型。笔记。默认情况下也可以在 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 通配符有这样的特定用例。

于 2019-11-03T04:22:30.850 回答
0

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

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

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

[...]

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

[...]

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

于 2018-03-16T09:40:00.180 回答