The Java Language Specification, Third Edition

15.11.2 Accessing Superclass Members using super EXPRESSIONS
438
T, the expression s.z() refers to the z method of class T, despite the fact that the
type of the expression s is S. Method z of class T overrides method z of class S.
The following example demonstrates that a null reference may be used to
access a class (static) variable without causing an exception:
class Test {
static String mountain = "Chocorua";
static Test favorite(){
System.out.print("Mount ");
return null;
}
public static void main(String[] args) {
System.out.println(favorite().mountain);
}
}
It compiles, executes, and prints:
Mount Chocorua
Even though the result of favorite() is null, aNullPointerException is
not thrown. That “Mount ” is printed demonstrates that the Primary expression is
indeed fully evaluated at run time, despite the fact that only its type, not its value,
is used to determine which field to access (because the field mountain is static).
15.11.2 Accessing Superclass Members using super
The special forms using the keyword super are valid only in an instance method,
instance initializer or constructor, or in the initializer of an instance variable of a
class; these are exactly the same situations in which the keyword this may be
used (§15.8.3). The forms involving super may not be used anywhere in the class
Object, since Object has no superclass; if super appears in class Object, then a
compile-time error results.
Suppose that a field access expression super.name appears within class C,
and the immediate superclass of C is class S. Then super.name is treated exactly
as if it had been the expression ((S)this).name; thus, it refers to the field
named name of the current object, but with the current object viewed as an
instance of the superclass. Thus it can access the field named name that is visible
in class S , even if that field is hidden by a declaration of a field named name in
class C.
The use of super is demonstrated by the following example:
interface I { int x = 0; }
class T1 implements I { int x = 1; }
class T2 extends T1 { int x = 2; }
class T3 extends T2 {
DRAFT