Tag: Hiding

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.