Um, no, they can only be hidden by having a static method of the same name in the subclass. You don't get the polymorphic behavior you get with overriding if you hide a static method - for example:

class Base {

public static void aMethod(){
System.out.println ("Base aMethod()");
}
}

public class Baselet extends Base {

public static void aMethod (){
System.out.println ("Baselet aMethod()");
}

public static void main (String [] args){

Base theBase = new Baselet();
theBase.aMethod();

}
}

1) static methods do not have access to the implicit variable called this
2) a static method may not be overriden
3) a static method may not be overriden to be non-static
4) a static method may not be overloaded

So we should not mix-up the final and static behaviours. Try this.

class Parent {
	static void staticMethod() {}
	static final void staticFinalMethod() {}
	void instanceMethod() {}
	final void instanceFinalMethod() {}
}
class Child1 extends Parent {
	static void staticMethod() {}
	static final void staticFinalMethod() {} // You can't hide like this. 
      //You violate the law    
	void instanceMethod() {}
	final void instanceFinalMethod() {}
        //You can't override like this    
}

regds
maha anna

I think the answer to Art's question should be 1 & 3.
Actually I am confused .Please give detailed explaination as always.

rgds
Girish

Beleive me. I started answering your post in detail. Then It struck me why am I doing this? Does Girish just wants the answer. No, he has to give his explanation first. Then I can reply for him like that. Do you get Maha's idea? Let us discuss first. Then the answers come automatically. Please take it in the right sense. What's your opinion about Art's qstn?

According to Jims post , the statement

Static methods may not be overridden is true.

But your code:

/////////////////////////////////
class Parent {
static void staticMethod() {}
static final void staticFinalMethod() {}
void instanceMethod() {}
final void instanceFinalMethod() {}
}

class Child1 extends Parent {
static void staticMethod() {}
static final void staticFinalMethod() {} // You can't hide like this.
//You violate the law
void instanceMethod() {}
final void instanceFinalMethod() {}
//You can't override like this
}

///////////////////////////////////

Here what is the statement:

"static void staticMethod() {}"

in Child1? Is it overriding or hiding.

Morever the compiler error like:

"Cannot override static methods with instance methods "

doesn't it suggest you can override static methods with only static methods.

Actually what I mean is - Is overriding not a subset of hiding.

Hope u understand the question.I think i have messed up many things.

In order to analyze the static concept, let us take the same case as described above. Let's assume Both Base class and subclass has their own version of static void method(); This means what? Each class as a independent class of its own wants to give a COMMON behaviour for all objects created from them. This means when the subclass redefines the same static void method1(), it DOES NOT OVERRIDE. It hides. In the sense, If you apply the same 2 tests as shown above Base b = new Base(); b.method() WILL call Base class version. Subclass s = new Subclass(); s.method() WILL call subclass version. And you know waht? Base b = new Subclass() WILL NOT CALL SUBCLASS VERSION. IT WILL CALL THE BASE CLASS VERSION of the static method. Seeing a subclass object through a base class mirror and when we see a static method, the MIRROR type's static only will be seen. So the mirror beahves differently.

So do you get the point? If the static method WOULD HAVE BEEN OVERRIDEN we MUST see the subclass version right? Then why we see the static base class method? So static method are NOT OVERRIDEN.

For the compiler part, it does say anything about the 'hiding' IT throw s the same error for both instance and static methods. It DOES NOT DISTINGUISH between hiding and overring when it throws the error But it does its work fine.
regds
maha anna

When you say

BaseClass
   +SubClass1
       +SubClass2
           +SubClass3
               +SubClass4

After the above statement, when you call refVar.someStaticMethod(), the one which is defined in SubClass2 will be called.