Java Generics：覆盖参数化返回类型不同的方法

Question

I come from .Net and I'm pretty new to Java development so maybe that's a weird question:

I have a class hierarchy like:

Superclass implements GenericInterface<Superclass>
    ^
    |
 Subclass

where GenericInterface is pretty straight forward:

public interface GenericInterface<T> {
    OtherGenericInterface<T> getOther();
}

and OtherGenericInterface finally uses the type parameter:

public interface OtherGenericInterface<T> {
    List<Object> processType(T left, T right);
}

now when I try to implement the the interface in Superclass I simply return an anonymous type:

public class Superclass implements GenericInterface<Superclass> {
    @Override
    public OtherGenericInterface<Superclass> getOther() {
        return new OtherGenericInterface<Superclass>() {
            @Override
            public List<Object> processType(T left, T right) {
                ...
            }
        };
    }
}

That works fine so far but now I try to override the method in the Subclass :

public class Subclass extends Superclass (implements GenericInterface<Subclass>) {
    @Override
    public OtherGenericInterface<Subclass> getOther() {
        ...
    }
}

And in there, I can not override the method with my more specific return type. Even if I re-implement the interface and declare the method in the Superclass as final it is not possible.

So my question is: Why isn't OtherInterface<MoreSpecificType> a more specific, or at least the same type (due to type erasure) because that would be the requirement to override the method right?.

Answer 1

This demonstrates a common misconception with Java generics - believing that a match of a class will also match subclasses (like types of parameters). That is not the case. Java generics are designed to ensure that the types match exactly . If you want wriggle room you must specify and define what room you want and how much.

Here's a version that allows you to do what you want by exactly specifying the signature as <T extends Superclass> . This may not be exactly what you are looking for but I hope it points you in the right direction.

public interface OtherGenericInterface<T> {

    List<Object> processType(T left, T right);
}

public interface GenericInterface<T> {

    OtherGenericInterface<T> getOther();
}

public class Superclass<T extends Superclass> implements GenericInterface<T> {

    @Override
    public OtherGenericInterface<T> getOther() {
        return new OtherGenericInterface<T>() {
            @Override
            public List<Object> processType(Superclass left, Superclass right) {
                return null;
            }
        };
    }
}

public class Subclass extends Superclass {

    @Override
    public OtherGenericInterface<Subclass> getOther() {
        return null;
    }
}