Difference between 'super' and 'this'

Question

Possible Duplicate:
this and super in java

I'm new to development. Something that I'm still unable to understand is the difference between this and super keywords. If there are any answers, it would be highly appreciated. Thanks.

score 6 · Answer 1 · answered Apr 14 '12 at 16:41

this

Within an instance method or a constructor, this is a reference to the current object — the object whose method or constructor is being called. You can refer to any member of the current object from within an instance method or a constructor by using this.

super

If your method overrides one of its superclass's methods, you can invoke the overridden method through the use of the keyword super. You can also use super to refer to a hidden field (although hiding fields is discouraged).

score 1 · Answer 2 · answered Apr 14 '12 at 16:42

super refers to the base class that the current class extends. this refers to the current class instance.

So, if Parent extends Child and you create a new Child(), super refers to the Parent class (and doing something like super() in the constructor would call the parent's constructor) and this refers to the actual Child instance you created with new.

score 1 · Answer 3 · answered Apr 14 '12 at 16:42

1

Super refers to the superclass that a class extends. this refers to the current instance of a class.

answered Apr 14 '12 at 16:42

lrAndroid

2,834
18
27

score 1 · Answer 4 · answered Apr 14 '12 at 17:35

These concepts can be confusing for new developers, they will be more clear when you learn about extending classes (inheritance). Sometimes when you refer to a variable or method, you might be being ambiguous for example if you repeated a class variable name in a method, the compiler won't know which variable you are referring to, so you can use this to specify you are referring to the current class's variable (not the local variable). The following would be ambiguous (and WRONG):

class Bike
{
    int speed = 10;
    public setSpeed(int speed)
    {
        speed = speed;
    }
}

The compiler would have no idea what you intended, and will probably insult you with a cryptic (for a new developer) error message. Using this in the following way tells the compiler "I am referring to the class level variable, NOT the method level variable"

class Bike
{
    int speed = 10;
    //Constructors and shiz
    public void setSpeed(int speed)
    {
        this.speed = speed;
    }
}

(Although in practice you shouldn't duplicate variable names in this way!) So to summarise, this tells the compiler that you're referring to the CURRENT class. Further ambiguity can arise when you extend classes (inherit functionality for a parent or super class), because the option of overriding the parent method arrises.

class Bike
{
    public Bike()
    {}

    public void printSpeed()
    {
        System.out.println("This generic bike can go 10 m/s!!");
    }
}

Now if we were to extend the bike class by introducing a more specific type of bike, we may want to override the printSpeed method to give the speed of our shiny new bike, like so:

class MountainBike extends Bike
{
public MountainBike() {}

public void printSpeed()
{
    System.out.println("WHOAAAH!! MOUNTAIN BIKE GOES 100 m/s!!");
}

public void printGenericSpeed()
{
    super.printSpeed();
}
}

The super.printSpeed() tells the compiler to run this method from the parent class, so a call to super.printSpeed() would actually call the printSpeed() method in the Bike class. The following code:

public static void main(String args[])
{
    MountainBike mb = new MountainBike();
    mb.printSpeed();
    mb.printGenericSpeed();
}

will print

WHOAAAH!! MOUNTAIN BIKE GOES 100 m/s!!
This bike can go 10 m/s!!

Note that if we had not overridden the printSpeed() method, calling the following would be a call to the printSpeed() method of the Bike class.

public static void main(String args[])
{
    MountainBike mb = new MountainBike();
    mb.printSpeed();
}

would print

This bike can go 10 m/s!!

So to conclude, we use this to refer to the current class we're in, and super to refer to the parent of the class we're in.

score 0 · Accepted Answer · answered Apr 14 '12 at 16:54

In Java the keyword this refers to the current object of a class, like in:

class Point {
    public int x = 0;
    public int y = 0;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public String toString() {
       return x + "," + y;
    }
}


class Point3D extends Point {
    public int z = 0;

    public Point(int x, int y, int z) {
        super(x,y);
        this.z = z;
    }

    public String toString() {
       return super.toString() + "," + z;
    }
}

In the constructor of the class Point this.x refers to the x defined in the class, where x is the parameter passed into the constructor. Here this is used to resolve the ambiguity of the name x. The same thing is true for y.

In the class Point3D the method toString() uses the return value of the super class Point to produce its own return value.

score 0 · Answer 6 · answered Apr 14 '12 at 16:56

this: is the reference to the current object in the methods of its class. Refer to any member of the current object through the this keyword.

super: is the derived class' parent when your class extends it through the extend keyword, and you can invoke the overridden method through the use of the keyword super. You can also use super to refer to a protected fields.

score 0 · Answer 7 · answered Apr 14 '12 at 17:02

this keyword refers to the current instance at that point in time. super keyword refers to the parent/super class of the current class.

EX:

class Test
{
     Test()
     {

     }
     Test(int i)
     {
           System.out.println("i=" + i);                
     }
}

 class Sample extends Test
 {

  int i;

  void Sample(int i)  //constructor 
  {
      this.i=i; // referring class version of the i using 'this'

      super(i); // passing parameter to Super/Parent class constructor. 
  } 

}

Difference between 'super' and 'this'

7 Answers7