this vs super in Java, with Examples

In Java, this is a reference to the current object, the one whose method or constructor is running, and superis that same object seen through its parent class, which you use to call the parent's version of a method or run the parent's constructor. Below, this.field, this(), super.method() and super() run side by side in programs you can step through, followed by the rules javac enforces and two tables that compare them.

It prints Rex is an animal and a dog, and each line with this or super does one job. In Dog's constructor, super(name) runs Animal's constructor, so the part of the dog it inherits is set up first. Inside that constructor, this.name = name stores the parameter in the name field of the object being built; this is the dog, even though the code is in Animal. In Dog's describe(), super.describe() runs Animal's version of the method, and the dog adds " and a dog" to what it returns. Step through it and watch the memory view: there is one Dog object the whole time, and this and super both lead to it.

this vs super: the difference#

this and super refer to the same object. The difference is where Java looks for the member you name: this.sound() runs the object's own version, while super.sound() runs the version in the parent of the class you are writing, skipping any override.

The this keyword: fields, methods and the current object#

this is a reference to the object a method or constructor is running on: during rex.describe(), this is the object rex points at. Its most common job is telling a field apart from a parameter with the same name, in a constructor or a setter.

It prints Ada: 150, then Ada Lovelace: 150. In the constructor and in setOwner, the parameter has the same name as the field, and the closer name wins, so a bare owner means the parameter. this.owner means the owner field of this object, which makes this.owner = owner copy the parameter into the field. In deposit there is no clash, so balance alone already means the field. this.printSummary() calls another method on the same object; plain printSummary() does exactly the same, because Java puts the this. in for you.

Passing this and returning this#

this is an ordinary reference, so a method can hand it to another object or return it. Returning this lets calls chain, one after another on the same object; StringBuilder's append works this way.

It prints Cooking [tea, cake, juice]. Each add puts an item in the list and returns this, the same order, so the next .add(...) in the chain runs on it. sendTo passes thisto the kitchen, which reads the order's items through its own parameter. Step through it: kitchen.cook(this) hands over the very object that order points at, not a copy.

this(): calling another constructor of the same class#

this(...) with parentheses runs another constructor of the same class, so a short constructor can fill in default values and hand the real work to a fuller one.

It prints large with olives, small with cheese and medium with cheese. new Pizza() runs the constructor with no parameters, which hands over with this("medium"); that one hands over with this(size, "cheese"); and only the two-parameter constructor sets the fields, so the setup is written once. Constructors may not hand over to each other in a loop: javac reports recursive constructor invocation. The constructors lesson covers chaining in full.

super.method(): the parent's version of a method#

super.method()runs the parent class's version of a method, on the same object, even when the current class overrides it. That is how an override builds on the method it replaces, as Dog's describe() did at the top of this page. Here one dog calls both versions of sound().

It prints this.sound() gives Woof, then super.sound() gives .... Step through it: the narration says both calls run on the Dog object, yet the first jumps into Dog's sound() and the second into Animal's. super is not a second, hidden Animal object inside the dog. There is one object, and super only changes where Java looks for the method: in the parent class, past the override.

Inside an override, super. is also what stops the method calling itself. If Dog's sound() called plain sound(), it would run itself again and again until Java gave up with a StackOverflowError. super always starts at the direct parent class, and Java has no super.super for skipping a level. Overriding itself is explained in method overloading vs overriding.

Key idea

There is only one object. this and super are two ways of looking up its members: this from the object's own class, super from the parent of the class the code is written in.

dog
dog
animal

super(): running the parent class's constructor#

super(...) with parentheses runs a constructor of the parent class, so the part of the object the subclass inherits is set up first, with the values it needs. In the first program, Dog's constructor called super(name) because Animal's only constructor takes a name.

If a constructor contains neither this(...) nor super(...), Java inserts super()at its start: a call to the parent's constructor that takes no arguments. That only works if the parent has one. Here Animal has only Animal(String name), and Dog's constructor does not call it:

Main.java:19: error: constructor Animal in class Animal cannot be applied to given types;
    Dog(String breed) {
                      ^
  required: String
  found:    no arguments
  reason: actual and formal argument lists differ in length
1 error

javac points at the opening brace of Dog's constructor, where it tried to insert super(): Animal's constructor needs a String (required: String), and the inserted call has nothing to give it (found: no arguments). The fix is to call the parent's constructor yourself: give Dog a name parameter as well, and pass it on with super(name). A subclass with no constructor at all gets the same error, because the default constructor Java writes for it also calls super().

In what order do constructors run?#

The parent's constructor finishes first: Java runs it before the statements that follow super(...) in the subclass constructor, so an object is built from the top of the family down. That holds whether you write super(...) yourself or Java inserts it, and this program has both, plus a this(...).

It prints Animal constructor, Dog constructor, Puppy(int) constructor, Puppy() constructor and Done: Rex, 3 months. new Puppy() starts in Puppy(), which hands over with this(3) before printing anything. Puppy(int) calls super("Rex"), and Dog(String), which has neither call, gets an inserted super() that runs Animal(). Each constructor prints only after the one it called has finished, so the most general class prints first. Step through it and watch four constructors start before the first line appears.

Key idea

Every chain of constructors ends with a call to the parent class, so the parent's part of an object is set up before the subclass's code uses it.

this() vs super(), and can a constructor call both?#

this() calls another constructor of the same class and super() calls a constructor of the parent class. A constructor may contain at most one of them, so it either hands over within its own class or calls up to the parent, never both.

You never need both. The constructor that this(...) hands over to calls super(...) itself, written or inserted, so the parent part is still built, exactly once. A constructor that contains both does not compile: javac reports redundant explicit constructor invocation.

Statements before this() or super() since Java 25#

Until Java 25, this(...) or super(...)had to be the very first statement of a constructor. Java 25 relaxed that rule with a feature called flexible constructor bodies: statements may now come before the call, as long as they do not use the object being built. They can check or adjust the parameters and work out values in local variables, but they cannot read the object's fields or call its methods. Those statements run before the parent's constructor, while the inherited part of the object is not set up yet, which is why the object is off limits to them.

It prints 100.0 degrees Celsius. The constructor works out the Celsius value from its parameter before handing it to Reading's constructor, and touches nothing of the object until super(celsius) has run. Most Java code you will read still puts the call first; the inheritance lesson shows another example of each style.

Can you use this or super in a static method?#

No: a static method runs without any object, so there is no current object for this or super to refer to. main is static, which is why this program fails:

Main.java:5: error: non-static variable this cannot be referenced from a static context
        System.out.println(this.name);
                           ^
1 error

super.toString() in the same place gets the same message, with super in place of this. To use an object from a static method, create one with new and call its methods through a variable, as every main on this page does. The this keyword and object references lesson goes further into what this holds.