Java – why did this method call fail? (generic and wildcard)

I received the following error:

'call(ContainsMonitor)' cannot invoke 'call(? extends webscout.Monitor)' in 'WebScoutCallable'

Monitor. java

WebScoutCallable<? extends Monitor> handler;

public setCallable(WebScoutCallable<? extends Monitor> callable) {
     this.handler = callable;
}

WebScoutCallable. java

public interface WebScoutCallable<T extends Monitor> {
     public void call(T caller);
}

ContainsMonitor. java

public class ContainsMonitor extends Monitor {
     public void handleDocument() {
          handler.call(this);
     }
}

I'm free to admit that I'm not familiar with Java itself I find the error message confusing because it looks like it should work (the method declaration requires a monitor or subclass, and I pass in a subclass) Any help (explanation) will be greatly appreciated!

thank you!

Solution

There is a wildcard in the type parameter of your handler variable The compiler does not know the exact type of this type parameter, but it is a monitor or subclass

The call method uses T to match the wildcard However, there is no guarantee that the wildcard type is containsmonitor It can be a monitor or monitorsubtypethatdoesntexistyet Because the compiler does not know the actual type, it does not allow anything other than null to be passed, because it cannot guarantee type safety for any non null parameter

You can solve this problem by removing wildcards and replacing the concept with type parameters on the monitor class

class Monitor<T extends Monitor<T>>
{
    WebScoutCallable<T> handler;

    public void setCallable(WebScoutCallable<T> callable) {
         this.handler = callable;
    }
}

The webscoutcallable interface changes slightly in the response:

interface WebScoutCallable<T extends Monitor<T>> {
    public void call(T caller);
}

When extending monitor, subclasses provide their own names as type parameters

class ContainsMonitor extends Monitor<ContainsMonitor> {
     public void handleDocument() {
          handler.call(this);
     }
}

Now, t will be a known type, and containsmonitor defines it as itself, so it is legal to pass itself to the call now