Question

Clarification: this question is not about access modifier

Confirmed that B.m() and b.m() statements both works in the following code:

class A {
  static void m() { //some code }
}

class B extends A {
}

class Example {
  public static void main (String [] args) {
    B.m(); // running A's m() static method
  }

  public void try() {
    B b = new B();
    b.m(); // running A's m() static method
  }
}

My question is can we said “static method is inherited”?

if “inherited” is the correct term, if we add a method to B class we same signature of the static class:

class A {
  static void m() { //some code }
}

class B extends A {
  static void m() { //some code }
}

class Example {
  public static void main (String [] args) {
    B.m(); // running B's m() static method
  }

  public void try() {
    B b = new B();
    b.m(); // running B's m() static method

    A a = new B();
    a.m(); // running A's m() static method, no polymorphism
  }
}

In this case, notice that we have no polymorphism, is it the correct term to said that “static method is inherited but not overridden, subclass static method hide superclass static method”?

Last doubt, for these 2 terms, “inherited” and “overriden”, which one is directly tied to the term “polymorphism” ?

Answer 1

Yes, I think “inherit” is the correct term here, even if it’s not as descriptive as it might be. From section 8.4.8 of the Java Language Specification:

A class C inherits from its direct superclass and direct superinterfaces all non-private methods (whether abstract or not) of the superclass and superinterfaces that are public, protected or declared with default access in the same package as C and are neither overridden (§8.4.8.1) nor hidden (§8.4.8.2) by a declaration in the class.

That doesn’t specify instance methods, but there are specific restrictions on what is allowed to hide or override what, which wouldn’t make sense if static methods were not inherited.

Really though, I would simply view static methods as “accessible without qualification” rather than anything else, given that they don’t take part in polymorphism etc. I think it’s worth being very clear about that – for example, one static method can hide an inherited one, but it can’t override it.

In other words, while I think “inherit” is technically correct, I would try to avoid using it without any further explanation.

For your second question, I’d say that based on the above, overriding is tied to polymorphism, but inheriting isn’t necessarily.

(I would also strongly advise you to avoid calling static methods “via” variables, and also to use the name of the class which declares the static method wherever you specify the name at all. I know that’s not part of the question, but I thought I’d just add it anyway…)