无法将类转换为Java中的泛型

Question

Please help resolve an issue regarding generics. I tried many ways but it's still not working. Problem is:

public static void main(String[] args) {
    Utils.execute(new TestAction(), new TestCallBack());
}

Compiler show error:

The method execute(Action<?>, CallBack<?,Action<?>>) in the type Utils is not applicable for the arguments (ImplementClass.TestAction, ImplementClass.TestCallBack)

My classes is:
Action class:

public abstract class Action<R> {
public R getResult() {
    return null;
}
}

TestAction class is:

class TestAction extends Action<String> {
    @Override
    public String getResult() {
        return super.getResult();
    }
}

Callback class is:

public interface CallBack<R, A extends Action<R>> {
public void onCall(A action);}

TestCallback class is:

class TestCallBack implements CallBack<String, TestAction> {

    @Override
    public void onCall(TestAction action) {

    }

}

And Utils class is:

public class Utils {
public static void execute(Action<?> action, CallBack<?, Action<?>> callback) {

}
}

Thanks a lot.

Answer 1

The second parameter of the execute method is CallBack<?, Action<?>> , and Action there means the Action class itself, subclass of it is not allowed. What you need there is - ? extends Action<?> ? extends Action<?> , which means either Action or some subclass of it.

Try changing the method signature -

public static void execute(Action<?> action, CallBack<?, ? extends Action<?>> callback) {

---

Note:

Generics are not co-variant. Take for example a method as follows -

static void method(List<Object> l) {}

And an invocation as follows is not allowed -

method(new ArrayList<String>());

Answer 2

You need to change two things,

TestCallBack should be like this -

public static class TestCallBack implements CallBack<String, Action<String>> {
  @Override
  public void onCall(Action<String> action) {
  }
}

and, Utils should be like this -

public static class Utils {
  // You need to ensure the same type, not just try and accept anything.
  public static <T> void execute(Action<T> action, CallBack<?, Action<T>> callback) {
  }
}

or using inner classes of a class called Question -

public abstract class Action<R> {
  public R getResult() {
    return null;
  }
}

public class TestAction extends Action<String> {
  @Override
  public String getResult() {
    return super.getResult();
  }
}

public interface CallBack<R, A extends Action<R>> {
  public void onCall(A action);
}

public class TestCallBack implements CallBack<String, TestAction> {
  @Override
  public void onCall(TestAction action) {
  }
}

public class Utils {
  public void execute(Action<?> action, CallBack<?, ? extends Action<?>> callback) {
  }
}

public static void main(String[] args) {
  Question question = new Question();
  question.new Utils().execute(question.new TestAction(), question.new TestCallBack());
}