Inheritance Hierarchy??

[Joe San]

Hi Ranchers,

Consider the following code,

class Superclass{
 protected double x = 3.0;
}
 
class TopLevelClass{
 private double x = 3.14;
 
class Inner extends Superclass{
  public void printHidden(){
   System.out.println("this.x" + this.x); //here what this implies??to whose x it is pointing??Is it pointing to the inherited x or the one in the super class. But I remember that super.x only points to the one in superclass...How about here???
   System.out.println("TopLevelClass.this.x" + TopLevelClass.this.x);
  }
 }
}

Please help me guys on the commented line over the code.

[marc weber]

Originally posted by Jothi Shankar Kumar Sankararaj:
...to whose x it is pointing?? Is it pointing to the inherited x or the one in the super class...

A main method would demonstrate the behavior...

public static void main(String[] args) {
  TopLevelClass.Inner in = new TopLevelClass().new Inner();
  in.printHidden();
}

[Chris Stann]

Call me silly, but I'm getting "non static variable this cannot be referenced from a static context" when I add your main method.

[Joe San]

Hi Above,

Where is the question of static here??

[Steven Gao Song]

"this" just refers to the instance object itself.
so "this.x" is the "x" defined in Superclass. Inner inherits x from Superclass.


You have to use "TopLevelClass.this.x" if you want to use "x" defined in the enclosing class "TopLevelClass".

[Joe San]

ok my question is,

In normal hierarchy(without any superclasses), like as below,

class SuperClass{
int x;
}
class SubClass{
SubClass(){
this.x; //means the one inherited
super.x;//means the one from the super class
}
}

So why is that when it comes to nested classes, this.x refers to the one in the superclass??
Anyone on this??

[marc weber]

Originally posted by Chris Stann:
Call me silly, but I'm getting "non static variable this cannot be referenced from a static context" when I add your main method.

class Superclass{
  protected double x = 3.0;
}
 
class TopLevelClass{
  private double x = 3.14;
 
  class Inner extends Superclass{
    public void printHidden(){
      System.out.println("this.x: " + this.x);
      System.out.println("TopLevelClass.this.x: " + TopLevelClass.this.x);
    }
  }
 
  public static void main(String[] args) {
    TopLevelClass.Inner in = new TopLevelClass().new Inner();
    in.printHidden();
  }
}

[ November 13, 2006: Message edited by: marc weber ]

[marc weber]

Originally posted by Jothi Shankar Kumar Sankararaj:
... So why is that when it comes to nested classes, this.x refers to the one in the superclass?? ...

I think you're letting the nesting confuse matters. As Song pointed out above, Inner extends Superclass. Superclass has a variable x, and Inner inherits this variable.

Now, if Inner defined its own variable 'x', then you would see a distinction between this.x and super.x.
[ November 13, 2006: Message edited by: marc weber ]

[Joe San]

Ok Mark,

so if inner defined x then this.x would mean accessing it's own x and super.x means accessing it's superclass x...Am I right...Since, the variable x is not defined by the inner class, this.x or super.x means the same...i.e accessing the inherited variable x.

I would be greatful if you could confirm this.

Thanks in advance.

[marc weber]

Originally posted by Jothi Shankar Kumar Sankararaj:
...I would be greatful if you could confirm this...

Exactly! Try this code, which includes both nested and non-nested examples. The behavior is the same.

class Superclass{
  protected String x = "Superclass";
}
 
class Subclass extends Superclass {
  private String x = "Subclass";
  public void printHidden(){
    System.out.println("x: " + x);
    System.out.println("this.x: " + this.x);
    System.out.println("super.x: " + super.x);
  }
}
 
class TopLevelClass{
  private String x = "TopLevelClass";
  class Inner extends Superclass{
    private String x = "Inner";
    public void printHidden(){
      System.out.println("x: " + x);
      System.out.println("this.x: " + this.x);
      System.out.println("super.x: " + super.x);
    }
  }
}
 
class Test {
  public static void main(String[] args) {
    Subclass sub = new Subclass();
    sub.printHidden();
    TopLevelClass.Inner in = new TopLevelClass().new Inner();
    in.printHidden();
  }
}

[Joe San]

Hi Mark,

My computer crashed and I have to wait for a couple of days untill I get my hard drive replaced and that was why, I have been posting theoretical questions rather than compiling and checking the result for myself.

Thanks a lot mark for the generous help.

[marc weber]

Originally posted by Jothi Shankar Kumar Sankararaj:
... My computer crashed and I have to wait for a couple of days untill I get my hard drive replaced...

Wow, sorry to hear that. The output for the above code is...

x: Subclass
this.x: Subclass
super.x: Superclass
x: Inner
this.x: Inner
super.x: Superclass

[Joe San]

Thanks again mark. I'm understanding the concept behind it.