Why calling super to reach a static member is ALWAYS illegal?

[Firas Zuriekat]

Just remember that the dot operator could be used to reach a static memeber...like Obj.staticMethod(). So why does this fail:

class HaveStatic {
static String shiny() { return "1"; }
}
class Test extends HaveStatic {
public static void main(String [] args) {
String s = shiny() + getShiny();
s = s + super.shiny();
System.out.println(s);
}
static String getShiny() { return shiny(); }
}
[ May 26, 2006: Message edited by: Firas Zureikat ]

[wise owen]

this and super

[Jeroen T Wenting]

Because you're not allowed to use super that way.
super refers to the superclass instance, which you don't have inside a static method.

[William CJ]

Since 'this' refers to an instance of the current type, static methods doesn't own any particular instance, it doesn't own a 'this' pointer. 'super' point to the super-class portion of the current instance, if static cannot even own a copy of the current instance how can it own the super-portion of it? Simply if you don't own a pie (this) you definitely don't have access to a portion of it (super).

[Firas Zuriekat]

Ok, thanks...So no "this" nor "super" could be used in any static methods.

[Dick Eimers]

You don't have access to a this or super in a static method. But when you do have access to this or super, i.e. in an instance method, the trick of invoking a static method a.k.a. class method using an object reference works just fine:

class SuperBla  {
 
    static void foo() { System.out.println("SuperBla.foo()"); } 
 
}
 
public class Bla extends SuperBla {
    
    static void foo() { System.out.println("Bla.foo()"); }     
 
    public static void main(String... argv) {

Bla bla = new Bla();
bla.instancemethod();
    }
 
    void instancemethod() {
 
Bla.foo();      // OK, obviously calls Bla.foo()
SuperBla.foo(); // OK, obviously calls SuperBla.foo();
this.foo();     // OK, calls Bla.foo();
super.foo();    // OK, calls SuperBla.foo();
    }

}

The type of the reference is used when invoking static methods using object references. The type of this is always the class in which it is used (Bla) and the type of super is always the superclass of the class in which it is used (SuperBla).

[Amirr Rafique]

If I summarize Dick's post we can say that
We can use super and this in a non-static method to access static methods BUT we can not use super or this in a static methods

Am I right?

[Firas Zuriekat]

Yes, you are right.....