Can I override a static method? – No you cant
Many people have heard that you can’t override a static method. This is true – you can’t. However it is possible to write code like this:
class test {
public static void method() {
System.out.println("in test");
}
}
class example extends test{
public static void method() {
System.out.println("in example");
}
}
This compiles and runs just fine. Isn’t it an example of a static method overriding another static method? The answer is no – it’s an example of a static method hiding another static method. If you try to override a static method, the compiler doesn’t actually stop you – it just doesn’t do what you think it does.
lets try it
Briefly, when you override a method, you still get the benefits of run-time polymorphism, and when you hide, you don’t. So what does that mean? Take a look at this code:
class test{
public static void classMethod() {
System.out.println("classMethod() in test");
}
public void instanceMethod() {
System.out.println("instanceMethod() in test");
}
}
class example extends test {
public static void classMethod() {
System.out.println("classMethod() in example");
}
public void instanceMethod() {
System.out.println("instanceMethod() in example");
}
}
class Test {
public static void main(String[] args) {
test f = new example();
f.instanceMethod();
f.classMethod();
}
}
If you run this, the output is
instanceMethod() in example
classMethod() in test
Now we should understand what is overriding and hiding-
Overriding
An instance method overrides all accessible instance methods with the same signature in superclasses [JLS 8.4.8.1], enabling dynamic dispatch; in other words, the VM chooses which overriding to invoke based on an instance’s run-time type [JLS 15.12.4.4]. Overriding is fundamental to object-oriented programming and is the only form of name reuse that is not generally discouraged:
class Base {
public void f() { }
}
class Derived extends Base {
public void f() { } // overrrides Base.f()
}
Hiding
A field, static method, or member type hides all accessible fields, static methods, or member types, respectively, with the same name (or, for methods, signature) in supertypes. Hiding a member prevents it from being inherited.
class Base {
public static void f() { }
}
class Derived extends Base {
public static void f() { } // hides Base.f()
}
Instance methods and class methods have this important difference in behavior, we use different terms – “overriding” for instance methods and “hiding” for class methods – to distinguish between the two cases. And when we say you can’t override a static method, what that means is that even if you write code that looks like it’s overriding a static method (like the first test and example at the top of this page) – it won’t behave like an overridden method.