question about return type of overriding the method

[thinkinjava24]

I met a problem when preparing the OCPJP, the problem is about overriding the method. here is the code:

class Lotest {
public int getInt() {
System.out.println("super");
return 1;
}
}
public class Oltest extends Lotest {
public float getInt() {
System.out.println("sub");
return 1.0f;
}
}
is this legal?
personally, I think it is illegal, since you can not override the method with changing the return type, however, the answer from the book is that this is fine from J2SE5.0, So I need to make sure of that. hope anyone could help me.. thanks a lot.

[sehudson]

The method signature has to be different.

[thinkinjava24]

So, you think this is illegal, right?
hope anyone can recommend some book that I can prepare for the OCPJP, I found so many book online but containing so much mistake....what a pity.

[sehudson]

No, I don't think that what you have done is legal. If the arguments that your getInt() method in your subclass took were different, this would be ok. Or, if the method signature was exactly the same, meaning the getInt() method in your subclass returned an int, and you used the @Override notation, you would be fine also. Look out for more responses though.

[Sierra]

It is illegal as sehudson says - you cannot change the type of a method by overriding like that. It is correct that a method is considered the same if it has the same method name, number of arguments and types of arguments.
To make it clearer the @Override annotation should be used here with getInt(). As is the code is not compiling.

[thinkinjava24]

Thank you for your response, my man!
the bad book almost mislead me.
can you recommend some reliable book for me to prepare the OCPJP?
also thanks Sierra.

[JosAH]

About the return types of overriding methods: before Java 1.5 a method m( ... ) that wants to override a method m( ... ) in a super class had to have the same signature as the method in the super class and exactly the same return type; starting from Java 1.5 this is not needed anymore, i.e. if m( ... ) in the super class returns a type T, the method m( ... ) in the sub class can return a type S as long as S is a sub class of T (because an S *is a* T, the term is 'covariant return type').

kind regards,

Jos