@Override annotation
After back from New Zealand, this the first time i officially used Java 5 and above to do coding, it is bit hard for me to code in Java 5, because i am not familiar with the Java 5 new features such as annotation, generics , boxing unboxing those stuffs.
And this @Override annotation had made me struggle for few hours. According to Javadoc,
Indicates that a method declaration is intended to override a method declaration in a superclass. If a method is annotated with this annotation type but does not override a superclass method, compilers are required to generate an error message.
So i assume this code will work fine:
interface K {
void method1();
}
class A implements K {
@Override
public void method1() {
}
}
But the compiler complains about it and giving the error: “The method method1() of type A must override a superclass method”.
I don’t know what is strong with the code, i thought maybe i used it in the wrong way at the beginning, i tested up with different case, end up i found out @Override annotation seems only applied to methods overridden from a superclass and not from Interfaces, i guess this is because implements interface but not override ! This had wasted my few hours !
However, this case not applied to Java 6, i switch compiler version to Java 6 and everything work fine. Weird !
hey thanks for commenting on my blog, every little bit helps. take care.
I’m not sure why there is difference between Java5 and Java6. From what I think is when a class implements a interface, all methods in the interface must be defined in the class else you will get compile time error. So it doesn’t matter whether you put “@Override” or not for the interface’s methods.
You say the Javadoc says “Indicates that a method declaration is intended to override a method declaration in a superclass”. Maybe Java5 think a interface is an interface and is difference from class. While Java6 maybe simply ignore the checking as it is not necessary to “@Override” an interface method as it is a must for a class to define it.
Maybe you are right, Java 5 thinks the interface is different from class, so implementation of the interface method is not consider overriding super class.
Class A is not overriding the void method1(); method signature but you are implementing it. Effectively you are overriding the implementation. Even this would not be a override
abstract class K {
public abstract void method1();
}
class A extends K {
public void method1() {
}
}
Because you are implementing an abstract method
If you were to override it you would have
abstract class K {
public void method1() {
}
}
class A extends K {
@Override
public void method1() {
}
}