Can Static, Private and Final Methods Be Overridden

"Can we override a static method?" is one of the most common Java interview questions, and the honest answer is "no, but you can write one that looks like an override". A static method with the same signature in a child class hides the parent's method instead of overriding it. The difference shows up the moment you call it through a parent-type variable. Private and final methods have their own reasons for being off limits, and fields behave like static methods, not like overridden ones.

One Reference, Four Answers

public class Hide {
    static class Parent {
        String name = "parent field";
        static String kind() { return "Parent.kind (static)"; }
        String who() { return "Parent.who"; }
        private String secret() { return "Parent.secret"; }
        String callSecret() { return secret(); }
    }
 
    static class Child extends Parent {
        String name = "child field";
        static String kind() { return "Child.kind (static)"; }
        @Override String who() { return "Child.who"; }
        private String secret() { return "Child.secret"; }
    }
 
    public static void main(String[] args) {
        Parent p = new Child();
        System.out.println(p.who());
        System.out.println(p.kind());
        System.out.println(p.name);
        System.out.println(p.callSecret());
    }
}

Child.who
Parent.kind (static)
parent field
Parent.secret

How it works

1. p.who(): an instance method, overridden. The object is a Child, so Child.who runs. This is the only polymorphic line.
2. p.kind(): a static method. Static methods belong to the class, not the object, so the compiler binds the call to the declared type Parent. Child.kind hides Parent.kind; it doesn't override it.
3. p.name: fields are never overridden. The child's name is a second, separate field that hides the parent's. Through a Parent variable you get the parent's field.
4. p.callSecret(): secret() is private, so Child can't see it and can't override it. Child.secret is an unrelated method that happens to share the name.

Static Methods: Hidden, Not Overridden

Calling a static method through an instance, as p.kind() does, is legal but misleading. Write Parent.kind() or Child.kind() instead, and the behavior becomes obvious.

You also can't mix the two kinds. A static method can't replace an instance method, or the other way round:

class A { static void s() {} void i() {} }
class B extends A {
    void s() {}
    static void i() {}
}

Mix.java:3: error: s() in B cannot override s() in A
    void s() {}
         ^
  overridden method is static
Mix.java:4: error: i() in B cannot override i() in A
    static void i() {}
                ^
  overriding method is static
2 errors

And @Override on a static method is rejected outright: error: static methods cannot be annotated with @Override.

Private and Final Methods

Private methods are also bound at compile time: calls to them always reach the class's own method, so a parent's helper can't be swapped out by a subclass. That's why calling private helpers from a constructor is safe, while calling overridable methods from a constructor is risky.

Common Mistakes

Expecting p.kind() to run the child's static method. It follows the declared type Parent.

Redeclaring a field in a subclass. You get two fields with the same name, and which one you read depends on the variable type. Use a method or a constructor argument instead.

Putting @Override on a private or static method. Both are compile errors, because there's nothing to override.

Interview Corner

Practice

1. Easy: Predict the output, then run it: Child c = new Child(); System.out.println(c.kind()); System.out.println(((Parent) c).kind()); using the classes above.
2. Harder: Replace the redeclared name field in Child with a name() method overridden in each class, and show that it now follows the object.

Key Takeaways