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 implement getAndParse
.
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 a getAndParse
method that I can use. When I call getAndParse
on that instance the compiler checks to see whether I have used specific instances of T
in the proper way, so in particular T
should extend AnotherClass
and it should be SpecificClass
.
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.