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

时间：2013-08-11 20:55:34

标签： java generics wildcard

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

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

有人可以点亮这个区域。

9 个答案:

答案 0 :(得分：149)

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

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

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

    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>和List<Float>作为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

    <强>参考文献：

答案 1 :(得分：10)

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

例如：

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) {
    ...
}

将List<S> src约束为属于T的子类的一个特定类S.该列表只能包含一个类的元素（在此实例中为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. */

答案 2 :(得分：9)

请考虑下面的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'。第一种方法不在书中。

答案 3 :(得分：2)

通配符方法也是通用的 - 您可以使用某种类型调用它。

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

此外，声明字段时无法避免?语法：

class NumberContainer
{
 Set<? extends Number> numbers;
}

答案 4 :(得分：2)

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

  

我们不认为像(Collection<? extends E> c);这样的外卡也是   支持多态性？

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

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

  

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

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

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

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. 是需要绑定的参数化类型。

我希望这会有所帮助。

答案 5 :(得分：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
    }
}

答案 6 :(得分：1)

？表示未知

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

简单的pojo车

int parsedTimeResult = 0;

Function TimeSubtraction() {
    setState(() {
      parsedTimeResult = selectedDate2.difference(selectedDate1).inDays;
    });
  }

这将编译

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
}

答案 7 :(得分：0)

据我所知，在严格需要通配符时只有一个用例（即可以使用显式类型参数表达无法表达的内容）。这是您需要指定下限时。

除此之外，通配符用于编写更简洁的代码，如您提及的文档中的以下陈述所述：

  

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

     

[...]

     

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

     

[...]

     

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

答案 8 :(得分：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通配符具有其特定的用例，例如。

相关问题
最新问题