Java generic method inheritance and override rules
Solution 1
What we are having here is two different methods with individual type parameters each.
public abstract <T extends AnotherClass> void getAndParse(Args... args);
This is a method with a type parameter named T, and bounded by AnotherClass
, meaning each subtype of AnotherClass
is allowed as a type parameter.
public <SpecificClass> void getAndParse(Args... args)
This is a method with a type parameter named SpecificClass
, bounded by Object
(meaning each type is allowed as a type parameter). Do you really want this?
Is the type parameter used inside Args
? I think the problem would be there.
The meaning of
public abstract <T extends AnotherClass> void getAndParse(T... args);
is that the caller of the method can decide with which type parameter he wants to call the method, as long as this is some subtype of AnotherClass
. This means that in effect the method can be called with any objects of type AnotherClass
.
Since the caller can decide the type parameter, you can't in a subclass narrow down the parameter type to SpecificClass
- this would not be an implementation of the method, but another method with same name (overloading).
Maybe you want something like this:
public abstract class GetAndParse<T extends AnotherClass> {
public SomeClass var;
public abstract void getAndParse(T... args);
}
public class Implementor extends GetAndParse<SpecificClass> {
// some field declarations
// some method declarations
@Override
public void getAndParse(SpecificClass... args) {
// method body making use of args
}
}
Now the getAndParse
method implements the parent class' method.
Solution 2
You are seeing this problem because of the concept called "Erasure" in Java Generics. Java uses "erasure" to support backward compatibility. i.e Java code which did not use generics.
Erasure Procedure:
The compiler will first do a type checking and then it will remove(erase) all the type parameters as much as possible, and also insert TypeCasting where ever necessary.
example:
public abstract <T extends AnotherClass> void getAndParse(T paramAnotherClass);
will become
public abstract void getAndParse(AnotherClass paramAnotherClass);
In class "Implementor.java",
The code
public <SpecificClass> void getAndParse(T paramAnotherClass)
will become
public void getAndParse(SpecificClass paramAnotherClass){ }
the compiler will see that you have not implemented the abstract method correctly. There is a type mismatch between the abstract method and the implemented method. This is why you are seeing the error.
More details can be found here. http://today.java.net/pub/a/today/2003/12/02/explorations.html
Solution 3
You cannot override to specific type T because there is in fact (at the bytecode level if you wish) only one method getAndParse
because of type erasure (see other answer):
public abstract void getAndParse(AnotherClass... args); // (1)
For every type of T, the same method is used.
You can overload it (I think):
public void getAndParse(SpecificClass... args); // (2)
but this will not a different method from (1) ant it will not be called by generic code:
T x = whatever;
object.getAndParse(x); // Calls (1) even if T is derived from SpecificClass
Solution 4
No, it's not valid. What would happen if someone with a GetAndParse
reference called it with a different class extending AnotherClass
?
Solution 5
That becomes a nonsense when someone has a reference to type GetAndParse and tries to call the getAndParse method. If Cat and Dog extend AnotherClass. I should expect to be able to call GetAndParse#getAndParse with either a Cat or a Dog. But the implementation has tried to restrict it and make it less compatible!
Related videos on Youtube
David K.
Updated on February 13, 2020Comments
-
David K. over 4 years
I have an abstract class that has a generic method and I want to override the generic method by substituting specific types for the generic parameter. So in pseudo-code I have the following:
public abstract class GetAndParse { public SomeClass var; public abstract <T extends AnotherClass> void getAndParse(T... args); } public class Implementor extends GetAndParse { // some field declarations // some method declarations @Override public <SpecificClass> void getAndParse(SpecificClass... args) { // method body making use of args } }
But for some reason I'm not allowed to do this? Am I making some kind of syntax error or is this kind of inheritance and overriding not allowed? Specifically I'm getting an error about
@Override
because the eclipse IDE keeps reminding me to implementgetAndParse
.Here's how I want the above code to work. Somewhere else in my code there is a method that expects instances of objects that implement
GetAndParse
which specifically means that they have agetAndParse
method that I can use. When I callgetAndParse
on that instance the compiler checks to see whether I have used specific instances ofT
in the proper way, so in particularT
should extendAnotherClass
and it should beSpecificClass
.-
irreputable about 13 yearspseudo code too abstract, need more info
-
maaartinus about 13 yearsUsing
public abstract <T extends AnotherClass> void getAndParse(Args... args);
makes no sense. What is the type parameter good for? How should the compiler determine its actual value and where should it use it? -
Paŭlo Ebermann about 13 yearsCould you get us a complete example, which is in fact compilable (apart from the problematic error) and produces the error you mentioned?
-
David K. about 13 years@maaartinus: You're right I've changed the methods to make specific use of the generic type.
-
-
David K. about 13 yearsI don't understand why this is a problem. I have an implementor that extends
GetAndParse
and fixes the type ofT
toSpecficClass
which the compiler checks to make sure extendsAnotherClass
then in my code when I have an instance ofImplementor
and callgetAndParse
with a type that doesn't matchSpecificClass
I should get an error. -
David K. about 13 yearsI don't want a type parameter. I want the compiler to check and make sure that
SpecificClass
is an extension ofAnotherClass
. -
Affe about 13 yearsThat is the reason that what you want to do is impossible, I apologize if I framed it in a way you don't like. Compile time generics are not capable of enforcing that for you. How is the compiler to know what subclass will be there at runtime? It's entirely possible the implementor is returned by a factory interface and comes from a different library you're not even compiling against! Narrowing of the type parameter cannot be checked for safety at compile time.
-
Erik about 13 years@davidk01: The contract provided by GetAndParse say that everyone implementing it must do so for any type extending AnotherClass. Given
GetAndParse foo = new Implementor();
you must able to callfoo.getAndParse
for any extension of AnotherClass - If the compiler didn't enforce this, you could just as well use Object, the point of generics is to ensure compile-time type safety -
Artjom B. over 5 yearsCan you be more descriptive by what you mean with your answer? I could guess that you're listing ways where Override doesn't work. But can you give an introduction why this has anything to do with this question? Please edit your answer to make it better.