Example from Angelica Langer FAQ - need help

Question

Hi everyone,
I found this example in the FAQ:
interface Acceptor<V> {
  void accept( Task<V> task, V v);
interface Task<U> {
  void go(Acceptor<? super U> acceptor);
class AcceptingTask<U> implements Task<U> {
  public void go(Acceptor<? super U> acceptor) {
    U result = null;
    ... produce result ...
    acceptor.accept(this, result);  // error
} And explanation for this:
"The argument of type U is fine because the declared argument type is an unknown
supertype of U . But the argument of type AcceptingTask<U> is a problem. The declared
argument type is an instantiation of Task for an unknown supertype of U . The compiler
does not know which supertype and therefor rejects all argument types. "
I have to admit that I am totally lost here. For me, calling accept method which takes
AcceptingTask<U> and U is fine :/ AcceptingTask is a Tak and U is a super type of
? super U. Could someone with a lot of patience to unteachable people could
explain it to me please ? ;)
Thanks,
Adrian

Answer 1

Here's a more concrete example:
public class Test
   public static void main(String[] args)
      AcceptingTask task = new AcceptingTask();
      Integer zero = Integer.valueOf(0);
      new NumberAcceptor().accept(task, zero);
interface Acceptor<V> {
  void accept( Task<V> task, V v);
interface Task<U> {
  void go(Acceptor<? super U> acceptor);
class AcceptingTask implements Task<Integer> {
  public void go(Acceptor<? super Integer> acceptor)
class NumberAcceptor implements Acceptor<Number>
   public void accept(Task<Number> task, Number n)
}So in the above the error is:
accept(Task<java.lang.Number>,java.lang.Number) in NumberAcceptor cannot be applied to (AcceptingTask,java.lang.Integer)
In other words, you can't pass a Task<Integer> to something that requires a Task<Number>.
So working back to the original code, the passed in Acceptor is Acceptor<? super U> which means that it's an acceptor of any valid super type of U. More specifically no matter what type U is, you can aalways pass in an Acceptor<Object>. If you had an AcceptingTask<String> you cannot use this as a Task<Object>.
The explanation, at least the part you quote isn't that great. It's isn't that the compiler doesn't know what the super type is, it's that it does know that a valid Acceptor (e.g. Accpetor<Object>) could be incompatible with the Task.