static method can be inherited?

[dolly shah]

ublic class High {
    public static String go(int... x){
        return"hi";
    }
}
class Low extends High{
    public static String go(Integer x,Integer y){return "low";}
    public static void main(String...args){
        System.out.println(go(9,27));
        System.out.println(go(81));
 
    }
}

output is "lowhi". Static method can be inherited? Can anyone please explain?

[ahmed yehia]

Static methods are inherited but cannot be overriden they can be re- defined. Its Compiler error if you try to override a static method with non static method or override non static method with static method.

[dolly shah]

Even final method is also inherited. But in K & B book it's written "only inherited methods can be override". But as we just saw you can inherit final & static methods but you cannot override them. Anyone explain?

[marc weber]

Originally posted by dolly shah:
...in K & B book it's written "only inherited methods can be override"...

This is not the same as saying, "all inherited methods can be overridden."

In other words, for a method to be overridden, inheritance is a requirement, but it is not the only requirement. The method must also be a non-final instance (non-static) method.

[Burkhard Hassel]

Howdy!

static methods aren't overridden, but redefined.

It is not called an override because they do not behave polymorphically as non-static methods do.

class A {
static String method() {
return "A";
}
}
 
class B extends A {
static String method() { // Redefinition
return "B";
}
}
 
class Main {
public static void main(String[] args) {
System.out.println(A.method()); // -> A
System.out.println(B.method()); // -> B
A polymorph = new B();
 
// allowed, but don't do that at home, kids:
System.out.println(polymorph.method()); // -> A  :eek: 
}
}

As I said, this is not called an override. If the method was non-static, the last line would produce a "B" because of polymorphism. For static method, only the variable type counts.
Therefore it is recommended not to call static methods on variables.


By the way, despite the fact that this is NO override, some behaviours are the same when comparing overriding and redefinition. For example you cannot make the static method in the child less visible than in the parent and you cannot throw broader exceptions.


final:
as in a non-static method where final does not allow overriding, in a static method final does not allow redefinition. When you make the method final in class A, class B will no longer compile.

Yours,
Bu.