static hidden methods, and overriden instance methods

[Wilson Mui]

Here is the question from the mock exam:

class P {
  static void printS1(){System.out.print("P.printS1 ");}
  void printS2() {System.out.print("P.printS2 ");}
  void printS1S2(){printS1();printS2();}
}
class Q extends P {
  static void printS1(){System.out.print("Q.printS1 ");}
  void printS2(){System.out.print("Q.printS2 ");}
  public static void main(String[] args) {
    new Q().printS1S2();
  }
}

What happens?
The answer is Prints: P.printS1 Q.printS2
Ok I can accept this answer at face value...but what is the rule. This seems like a totally arbitrary rule...but can somebody give me an overriding rule that makes sense, in terms of rationally why this should be. I don't believe the study guide I've been using has anything close to as obscure a question as this.

[Roger Chung-Wee]

It is essential to realise that the compiler will sort out whatever it can at compile-time, like anything static or overloaded methods. But overridden methods are sorted out at runtime.
Here we have this:
void printS1S2(){printS1();printS2();}
printS1() of class P is statically bound as it is not overridden. This gives you "P.printS1 ".
On the other hand, printS2() is overridden and is invoked depending on the type of object (Q). This gives you "Q.printS2 ".
[ April 24, 2003: Message edited by: Roger Chung-Wee ]

[John Zoetebier]

Method printS1S2() is inherited by subclass Q.
The compiler sees that printS1() is static and looks no further => method invocation resolved at compile time.
Method printS2() is an instance method => compiler creates a virtual method invocation that is resolved at runtime based on the actual object.
These programs ca be made easier to understand by taking 1 rule at a time.
below are 2 examples.
Program 1: static methods only.

class P {
static void printS1() {
System.out.println("P.printS1() ");
}
}
class Q extends P {
static void printS1() {
System.out.println("Q.printS1() ");
}
public static void main(String[] args) {

P p1 = new Q();
p1.printS1();
}
}  

Program 2: combines override and static.

 class P {
static void printS1() {
System.out.println("P.printS1() ");
}
void instancePrintS1() {
System.out.println("P: instancePrintS1()");
printS1();
}
}
class Q extends P {
static void printS1() {
System.out.println("Q.printS1() ");
}
void instancePrintS1() {
System.out.println("Q: instancePrintS1()");
printS1();
}
public static void main(String[] args) {

P p1 = new Q();
p1.instancePrintS1();
}
} 

[Jose Botella]

void printS1S2(){printS1();printS2();}
is the same as
void printS1S2() { this.printS1(); this.printS2() );
I guess the confussion steems from not knowing wich class to look for printS1, either P , or Q?.
Always begin the search of the method to invoke by the class that is the compile type of of the expression on which the method invocation occurrs.
this is the expression on which the method invocation occurs. The compile type of this is the class declaring the method where this happens to be. That is P. Search P for printS1 declaration, there is one. Stop there, coz printS1 is static you do not have to look at subclasses.
Now, when printS2 is located in P, trying to resolve which printS2 method is called, we note that is not static, so we look at the runtime type of this. In this.printS2(), this is a reference to an instance of Q. Which one? the one created by new Q() in main. In the class Q there is a method overriding P.printS2, that method is called on the instance hold by this.