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.