何时使用通用方法以及何时使用通配符？-Java 学习之路

问题

我正在阅读来自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);
    //嘿，类型变量也可以有界限！
}
[...]这告诉我们类型参数被用于多态;它唯一的作用是允许在不同的调用站点使用各种实际的参数类型。如果是这种情况，则应使用通配符。通配符旨在支持灵活的子类型，这是我们在此尝试表达的内容。

难道我们不认为像(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){
    ...
}

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

有人可以点亮这个区域。

#1 热门回答(128 赞)

某些地方，通配符和类型参数执行相同的操作。但也有一些地方，你必须使用类型参数。

如果要对不同类型的方法参数强制实施某些关系，则不能使用通配符，必须使用类型参数。

以你的方法为例，假设你要确保传递给copy()方法的src和destlist应该具有相同的参数化类型，你可以使用类型参数来执行此操作：

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

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

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

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

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

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

如果只有一个参数化类型参数，则可以使用通配符，尽管类型参数也可以使用。
类型参数支持多个边界，通配符不支持。
通配符支持上限和下限，类型参数只支持上限。因此，如果要定义一个采用Integer类型的List或它的超类的方法，你可以这样做：public void print(List <？super Integer> list)// OK
但你不能使用类型参数：public <T super Integer> void print(List <T> list)//将无法编译
参考文献：- Angelika Langer的Java Generics FAQs

#2 热门回答(8 赞)

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

例如：

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

在这里，你将根据某个标准提取一些T.如果T是Long，你的方法将返回Long和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) {
    ...
}

constrainList<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. */

#3 热门回答(4 赞)

考虑以下来自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
}

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

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

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

原文链接

何时使用通用方法以及何时使用通配符？

问题

#1 热门回答(128 赞)

#2 热门回答(8 赞)

#3 热门回答(4 赞)

相关问题