Question

我有一些返回通配符参数化类型的代码。我试图将其传递给参数方法，但是我遇到了编译器错误。有人可以向我解释为什么类型不匹配，解决这个问题的最佳方法是什么？

static <L extends List<T>,T extends Number>
void useList(List<L> list) {}

public static void main(String[] args) {
    List<List<? extends Number>> list = null;
    useList(list);
}

编译错误：

demo/GenericsHell.java:75: error: method useList in class GenericsHell cannot be applied to given types;
        useList(list);
        ^
  required: List<L>
  found: List<List<? extends Number>>
  reason: inference variable L has incompatible bounds
    equality constraints: List<? extends Number>
    upper bounds: List<CAP#1>
  where L,T are type-variables:
    L extends List<T> declared in method <L,T>useList(List<L>)
    T extends Number declared in method <L,T>useList(List<L>)
  where CAP#1 is a fresh type-variable:
    CAP#1 extends Number from capture of ? extends Number
1 error

在我的真实代码中，list由一个复杂的方法生成，该方法可以返回几种类型的“List”（实际上是一个自定义泛型类）。是否有另一种方法来参数化useList函数，以便它以类型安全的方式接受它？

修改1

我正在尝试将大量代码模块简化为一个简洁，连贯的问题。从答案我可以看出上面的代码过度简化了我所遇到的精确问题。我会尝试用更复杂的例子来重述，同时更好地指定我的约束。

首先，我实际上并没有使用List，而是使用双参数化的更复杂的类。我想不出任何标准类这样做，所以我将在示例中定义一个用于：

static class NumberLists<L extends List<T>,T extends Number> extends ArrayList<L> {}

我会避免多次重复使用某种类型，因此更容易保持水平。 useList（）方法确实需要双参数化，因为它在内部使用两种类型：

static <L extends List<T>,T extends Number>
Set<NumberLists<L,T>> useList(L list) {
    NumberLists<L,T> nl = new NumberLists<L, T>();
    nl.add(list);
    return Collections.singleton(nl);
}

只要你有一个具体的类，这个框架就会很好用：

    // Everything works with a concrete class
    List<Integer> intList = new ArrayList<Integer>();

    // Use with parametric functions
    Set<NumberLists<List<Integer>,Integer>> concreteSet = useList(intList);
    // Access & use elements
    NumberLists<List<Integer>,Integer> concreteNL = concreteSet.iterator().next();
    concreteNL.add(intList);

问题是我有一个输入列表，可以是几种不同的类型：

static List<? extends Number> makeList() {
    if(Math.random()<.5) {
        return new ArrayList<Integer>();
    } else {
        return new ArrayList<Double>();
    }
}

List<? extends Number> numList = makeList();

这打破了上面可能出现的许多模式。

    // What is the type here? This is obviously an error
    Set<NumberLists<? extends List<? extends Number>>,? extends Number> paramSet = useList(numList);
    // Type should ideally be compatible with numList still
    NumberLists<?,?> paraNL1 = paramSet.iterator().next();
    // Captures don't match
    paraNL1.add(numList);

所以问题是我在编译时无法知道numList的具体类。并且我不觉得我正在做任何实际上类型不安全的事情，因为我知道numList的类型必须匹配useList返回的类型，依此类推。

我可以控制代码大多数部分的类型签名。但是，我更喜欢以下内容：

它应该可以很好地使用具体类（例如intList）
它还将接收在运行时
如果执行强制转换或其他未经检查的操作，它们应该在输入的构造附近发生。应检查以下操作。

有关完整（但非编译）的java文件，请参阅https://gist.github.com/sbliven/f7babb729e0b1bee8d2dabe5ee979431。由于我对此问题感兴趣，请参阅https://github.com/biojava/biojava/issues/354。

Answer 1

问题是编译器想要为T分配具体类型。在您的声明中T需要根据? extends Number的声明成为list，这不是具体的。

您可以将useList更改为以下声明之一，编译器会很高兴：

static <L extends List<? extends Number>> void useList(List<L> list) {
}

（没有T，没问题）或

static <L extends List<? extends T>, T extends Number> void useList(List<L> list) {
}

（此处T将成为Number）。

如果你可以在变量声明中替换? extends Number，那么一切都会好的：

public static <T extends Number> void main(String[] args) {
    List<List<T>> list = null;
    useList(list);
}

Answer 2

对于第一个编译问题，您的问题来自于您尝试将其分配给某个类型不匹配的变量。

最简单的方法是从useList()调用开始，以确保这个简单的代码编译：

List<? extends Number> numList = makeList();
useList(numList);

如果您检查此代码，它已经编译。

现在请求IDE将结果分配给本地变量。 IDE将为您声明变量计算表达式的类型，并voilà：

Set<? extends NumberLists<? extends List<? extends Number>, ? extends Number>> paramSet =
    useList(numList);

（如果可能，请删除L上的NumbersList类型，这会简化很多事情）

对于paraNL1.add(numList);调用，由于通配符，它无法工作：编译器无法检查paraNL1是否接受未知类型的列表。

即使您按照相同的过程修改声明：

NumberLists<? extends List<? extends Number>, ? extends Number> paraNL1 =
    paramSet.iterator().next();

paraNL1.add(numList); // will still not compile

您发现自己正在尝试将paraNL1用作消费者（消耗numList），而PECS告诉您必须使用super为其声明工作。

实际上，编译器知道L extends List<? extends Number>必须存在某种类型NumberLists，但它不知道它，也无法检查它是否与numList的类型相匹配。 L可以是LinkedList<Float>，而numList可以是ArrayList<Integer>。

编辑：为了使其有效，您可以使用wilcard capture helper method这样的内容：

private static <T extends Number, L extends List<T>> void helper(L numList) {
    Set<NumberLists<L, T>> paramSet = useList(numList);
    NumberLists<L, T> paraNL1 = paramSet.iterator().next();
    paraNL1.add(numList);
}

（这甚至可以让你摆脱? extends NumerLists声明中的Set

并用

调用它

List<? extends Number> numList = makeList();
helper(numList);

Java两级参数化类型推断

2 个答案: