无法使用Java泛型推断类型

Question

I have two types(T,M) first one is recognized by the compiler second one isnt. any idea what am i doing wrong?

public class SendMessageResponse<T> {

    private T result;
}

public class MessageResponse<M> {

    private M message;
}

interface is defined this way:

public interface EventQueue<T, M> {

    SendMessageResponse<T> send(String address, String message, String eventId);

    void consumeBatch(String address, int numOfConsumersPerQueue, Handler<MessageResponse<M>> callback);

    ..
}

on impl:

public class EventQueueSQS
        implements EventQueue<SendMessageResultImpl, MessageImpl> {

    @Override
    public SendMessageResponse send(String address, String message, String eventId) {..}

    @Override
    public void consumeBatch(String address, int numOfConsumerThreads, Handler<MessageResponse> callback) {
    }

    ..
}

for the consumeBatch override method i have complication error:

Error:(164, 17) java: name clash: consumeBatch(java.lang.String,int,io.vertx.core.Handler<java.util.List<MessageResponse>>) in EventQueueSQS and consumeBatch(java.lang.String,int,io.vertx.core.Handler<java.util.List<MessageResponse<M>>>) in EventQueue have the same erasure, yet neither overrides the other

compiler force me on the method to write the impl:

public void consumeBatch(String address, int numOfConsumersPerQueue, Handler<MessageResponse<Message>> callback) {

why? I have declared it on the class level

any idea?

Perhaps the issue that Iam using Handler which holds class that has generics? I cant find the diff between SendMessageResponse or using Handler> regarding generics as the first one works and the other one doesnt

Answer 1

When compiled to bytecode type parameters such as M are transformed to their bound implementation type if bounded or Object if unbounded see this .Since you provide no implementation type in the method of your class EventQueueSQS , both the interface method and the class method are compiled to Handler<MessageResponse<Object>> which creates a clash error. So you need to provide-bind an implemented type for your type parameter M in your class method,which in your case is MessageImpl.

If you dont want to provide an actual implementation type in your class EventQueueSQS either remove <M> from Handler<MessageResponse<M>> in the interface, or make your class also parameterized like EventQueueSQS<T,M> implements EventQueue<T,M> where you still have to provide it inside your method's argument but as a parameter M , and this way you can create instances like EventQueueSQS<SendMessageResultImpl,MessageImpl> .

Answer 2

In your method you set the argument type:

Handler<MessageResponse> callback

But this is the same as

Handler<MessageResponse<Object>> callback

and this does conflict with your type M which is MessageImpl . If you are using a Java version supporting the diamond operator, it may allow you to write Handler<MessageResponse<>> callback which is the same as the compiler-suggested one.

Answer 3

Here is your concrete implementation:

public class EventQueueSQS
    implements EventQueue<SendMessageResultImpl, MessageImpl> {

    @Override
    public SendMessageResponse send(String address, String message, String eventId) {..}

    @Override
    public void consumeBatch(
            String address, 
            int numOfConsumerThreads, 
            Handler<MessageResponse> callback) {
    }

    ..
}

According to your interface definition, this is not an appropriate match for the signature of your consumeBatch method. You need:

    public void consumeBatch(
            String address, 
            int numOfConsumerThreads, 
            Handler<MessageResponse<MessageImpl>> callback) {
    }