java 报错 对put的引用不明确,Java类型推断：引用在Java 8中是不明确的，但不是Java 7...

Lets say we have 2 classes. An empty class Base, and a subclass of this class Derived.

public class Base {}

public class Derived extends Base {}

Then we have a few methods in another class:

import java.util.Collection

public class Consumer {

public void test() {

set(new Derived(), new Consumer().get());

}

public T get() {

return (T) new Derived();

}

public void set(Base i, Derived b) {

System.out.println("base");

}

public void set(Derived d, Collection extends Consumer> o) {

System.out.println("object");

}

}

This compiles and runs successfully in Java 7, but does not compile in Java 8. The error:

Error:(8, 9) java: reference to set is ambiguous

both method set(Base,Derived) in Consumer and

method set(Derived,java.util.Collection) in Consumer match

Why does work in Java 7, but not Java 8? How could ever match Collection?

解决方案

The problem is that the type inference has been improved. You have a method like

public T get() {

return (T) new Derived();

}

which basically says, “the caller can decide what subclass of Base I return”, which is obvious nonsense. Every compiler should give you an unchecked warning about your type cast (T) here.

Now you have a method call:

set(new Derived(), new Consumer().get());

Recall that your method Consumer.get() says “the caller can decide what I return”. So it’s perfectly correct to assume that there could be a type which extends Base and implement Collection at the same time. So the compiler says “I don’t know whether to call set(Base i, Derived b) or set(Derived d, Collection extends Consumer> o)”.

You can “fix” it by calling set(new Derived(), new Consumer().get()); but to illustrate the madness of your method, note that you can also change it to

public > void test() {

set(new Derived(), new Consumer().get());

}

which will now call set(Derived d, Collection extends Consumer> o) without any compiler warning. The actual unsafe operation happened inside the get method.

So the correct fix would be to remove the type parameter from the get method and declare what it really returns, Derived.

By the way, what irritates me, is your claim that this code could be compiled under Java 7. Its limited type inference with nested method calls leads to treating the get method in a nested invocation context like returning Base which can’t be passed to a method expecting a Derived. As a consequence, trying to compile this code using a conforming Java 7 compiler will fail as well, but for different reasons.