java - 引用与泛型不明确

Question

我在这里遇到了一个非常棘手的泛型和方法重载案例。查看这个示例类:

public class Test {
    public <T> void setValue(Parameter<T> parameter, T value) {
    }

    public <T> void setValue(Parameter<T> parameter, Field<T> value) {
    }

    public void test() {
        // This works perfectly. <T> is bound to String
        // ambiguity between setValue(.., String) and setValue(.., Field)
        // is impossible as String and Field are incompatible
        Parameter<String> p1 = getP1();
        Field<String> f1 = getF1();
        setValue(p1, f1);

        // This causes issues. <T> is bound to Object
        // ambiguity between setValue(.., Object) and setValue(.., Field)
        // is possible as Object and Field are compatible
        Parameter<Object> p2 = getP2();
        Field<Object> f2 = getF2();
        setValue(p2, f2);
    }

    private Parameter<String> getP1() {...}
    private Parameter<Object> getP2() {...}

    private Field<String> getF1() {...}
    private Field<Object> getF2() {...}
}

上面的例子在 Eclipse (Java 1.6) 中可以完美编译，但不能使用 Ant javac 命令(或使用 JDK 的 javac 命令)，我在第二次调用 setValue 时收到此类错误消息:

reference to setValue is ambiguous, both method setValue(org.jooq.Parameter,T) in Test and method setValue(org.jooq.Parameter,org.jooq.Field) in Test match

根据规范和我对 Java 编译器工作原理的理解，应始终选择最具体的方法:http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#20448

无论如何，即使<T>绑定(bind)到Object ，这使得 setValue方法可接受的调用候选方法，带有 Field 的方法参数似乎总是更具体。它可以在 Eclipse 中工作，只是不适用于 JDK 的编译器。

更新:

像这样，它可以在 Eclipse 和 JDK 编译器中工作(当然，带有 rawtypes 警告)。我了解，the specs 中指定的规则当涉及泛型时，它们非常特别。但我觉得这很令人困惑:

    public <T> void setValue(Parameter<T> parameter, Object value) {
    }

    // Here, it's easy to see that this method is more specific
    public <T> void setValue(Parameter<T> parameter, Field value) {
    }

更新 2:

即使使用泛型，我也可以创建此解决方法，避免使用 <T> 类型被绑定(bind)到 Object在 setValue调用时间，通过添加一个名为 setValue0 的附加明确间接.这让我觉得 T 的绑定(bind)至Object真的是这里造成所有麻烦的原因:

    public <T> void setValue(Parameter<T> parameter, T value) {
    }

    public <T> void setValue(Parameter<T> parameter, Field<T> value) {
    }

    public <T> void setValue0(Parameter<T> parameter, Field<T> value) {
        // This call wasn't ambiguous in Java 7
        // It is now ambiguous in Java 8!
        setValue(parameter, value);
    }

    public void test() {
        Parameter<Object> p2 = p2();
        Field<Object> f2 = f2();
        setValue0(p2, f2);
    }

我在这里误解了什么吗？是否存在与此相关的已知编译器错误？或者是否有解决方法/编译器设置可以帮助我？

跟进:

对于那些感兴趣的人，我已经向 Oracle 和 Eclipse 提交了错误报告。 Oracle 已经接受了这个 bug，到目前为止，Eclipse 已经分析并拒绝了它!看起来我的直觉是正确的，这是 javac 中的一个错误

• http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7031404
• https://bugs.eclipse.org/bugs/show_bug.cgi?id=340506
• https://bugs.eclipse.org/bugs/show_bug.cgi?id=469014 (Eclipse Mars 的新问题)

Answer 1

JDK 是对的。第二种方法并不比第一种更具体。来自 JLS3#15.12.2.5

“非正式的直觉是，如果第一个方法处理的任何调用都可以传递给另一个方法而不会出现编译时类型错误，那么一个方法比另一个方法更具体。” p>

这显然不是这里的情况。我强调了任何调用。一种方法比另一种更具体的属性完全取决于这两种方法本身；每次调用都不会改变。

对你的问题的正式分析:m2 比 m1 更具体吗？

m1: <R> void setValue(Parameter<R> parameter, R value) 
m2: <V> void setValue(Parameter<V> parameter, Field<V> value) 

首先，编译器需要从初始约束中推断出 R:

Parameter<V>   <<   Parameter<R>
Field<V>       <<   R

结果是R=V ，根据 15.12.2.7 中的推理规则

现在我们替换为 R并检查子类型关系

Parameter<V>   <:   Parameter<V>
Field<V>       <:   V

根据 4.10.2 中的子类型规则，第二行不成立。所以 m2 并不比 m1 更具体。

V不是 Object在这个分析中；分析考虑了 V 的所有可能值.

我建议使用不同的方法名称。重载从来都不是必需品。

---

这似乎是 Eclipse 中的一个重大错误。规范非常清楚地表明在此步骤中未替换类型变量。 Eclipse 显然首先进行类型变量替换，然后检查方法特异性关系。

如果这种行为在某些示例中更“明智”，那么在其他示例中则不是。说，

m1: <T extends Object> void check(List<T> list, T obj) { print("1"); }
m2: <T extends Number> void check(List<T> list, T num) { print("2"); }

void test()
    check( new ArrayList<Integer>(), new Integer(0) );

“直观地”，按照规范，m2 比 m1 更具体，并且测试打印“2”。但是，如果替换 T=Integer先做完，两个方法就一样了!

---

对于更新 2

m1: <R> void setValue(Parameter<R> parameter, R value) 
m2: <V> void setValue(Parameter<V> parameter, Field<V> value) 

m3: <T> void setValue2(Parameter<T> parameter, Field<T> value)
s4:             setValue(parameter, value)

这里，m1不适用于方法调用s4，所以m2是唯一的选择。

根据15.12.2.2，要查看m1是否适用于s4，首先进行类型推断，得出R=T的结论；然后我们检查Ai :< Si , 这导致 Field<T> <: T ，这是错误的。

这与前面的分析一致——如果m1适用于s4，那么m2处理的任何调用(本质上与s4相同)都可以由m1处理，这意味着m2会比m1更具体，这是错误的。

在参数化类型中

考虑下面的代码

class PF<T>
{
    public void setValue(Parameter<T> parameter, T value) {
    }

    public void setValue(Parameter<T> parameter, Field<T> value) {
    }
}

void test()

    PF<Object> pf2 = null;

    Parameter<Object> p2 = getP2();
    Field<Object> f2 = getF2();

    pf2.setValue(p2,f2);

这编译没有问题。根据 4.5.2，PF<Object> 中的方法类型是 PF<T> 中的方法替换 T=Object .即pf2的方法是

    public void setValue(Parameter<Object> parameter, Object value) 

    public void setValue(Parameter<Object> parameter, Field<Object> value) 

第二种方法比第一种更具体。