Question

I have the following definition:

public interface MessageResponseHandler<T extends MessageBody> {
    public void responsed(Message<T> msg);
}

public class DeviceClientHelper {
    public MessageResponseHandler<? extends MessageBody> messageHandler;

    setHandler(MessageResponseHandler<? extends MessageBody> h){
        this.messageHandler = h;
    }

    public someMethod(Object message){
        Message<? extends MessageBody> msg = (Message<? extends MessageBody>) message;
        if (this.messageHandler != null) {
            this.messageHandler.responsed(msg);
        }
    }
}

I couldn’t figure out why in the someMethod() method, the invocation of

this.messageHandler.responsed(msg);

would give me a wired compiler error in eclipse. something like:

the method responsed(Message<capture#3-of ? extends MessageBody>) in
the type MessageResponseHandler<capture#3-of ? extends MessageBody> is
not applicable for the arguments (Message<capture#4-of ? extends
MessageBody>)

what is the “catpure” means in the error message anyway?

Answer 1

You’re saying DeviceClientHelper has a messageHandler for some subclass of MessageBody. And someMethod has a message also for some subclass of MessageBody. However, there’s nothing requiring them to be the same subclass of MessageBody, so the call to responsed is not valid.

To make them use the same subclass, make the DeviceClientHelper generic on a specific subclass of MessageBody like so:

interface MessageResponseHandler<T extends MessageBody> {
    public void responsed(Message<T> msg);
}

public class DeviceClientHelper<T extends MessageBody> {
    public MessageResponseHandler<T> messageHandler;

    void setHandler(MessageResponseHandler<T> h){
        this.messageHandler = h;
    }

    public void someMethod(Object message){
        Message<T> msg = (Message<T>) message;
        if (this.messageHandler != null) {
            this.messageHandler.responsed(msg);
        }
    }
}

However, your MessageResponseHandler interface probably doesn’t need to care about the MessageBody class. This depends on how it’s actually used, but something like this might work better:

interface MessageResponseHandler {
    public void responsed(Message<? extends MessageBody> msg);
}

And then you can remove the generic type from the messageHandler field and keep the original someMethod implementation.