Difference Between this and super in Java

In Java, the keywords "super" and "this" are essential for interacting with classes and objects. In addition to referring class members, they assist in managing inheritance. Java also provides the this() and super() constructors, which are used in the context of constructors.

this keyword and this() constructor

this keyword

It is a reserved keyword in Java that refers to the current instance of the class. It is a reference variable through which the method is called. Other uses of this keyword are:

• It refers to the current class instance variable.
• It invokes the current class method (implicitly).
• We can pass it as an argument in the method and the constructor calls.
• It returns the current class instance from the method.

this() Constructor

In Java, this() is a special constructor call used within another constructor of the same class to invoke a different constructor. It helps with constructor chaining, which allows us to reuse initialization logic and reduce redundancy.

• It must be the first statement in the constructor.
• It can only be used inside constructors, not in methods.
• It helps in calling overloaded constructors from one another.

Example: Use of this Keyword and this() Constructor

Output:

We are inside the parameterized constructor.
The value of y = 10
We are inside the default constructor.
The value of x = 5
Inside Main

Usages of this Keyword

• Regarding Instance Variables: It is beneficial to distinguish between local and instance variables that share the same name.
• Calling Another Constructor: We can call one constructor from another within the same class by using the this() keyword.
• Calling Current Class Methods: The ability to call a method of the same class without explicitly constructing an object is known as "calling current class methods."
• Returning the Current Object: It allows us to get the current instance of a class from a method.
• Providing the Current Object as a Parameter: It facilitates giving the current object to a different constructor or method as an argument.

super Keyword and super() Constructor

super Keyword

A reserved keyword used to call the base class method or variable is known as a super keyword. We cannot use the super keyword as an identifier. The super keyword is not only used to refer to the base class instance but also to static members.

Note: The super keyword cannot be used to access static methods or variables directly. Static context is handled differently.

super() Constructor

super() is a special call used inside a subclass constructor to invoke the constructor of its superclass. It ensures that the superclass is properly initialized before the subclass adds its own features. Always the first statement in a subclass constructor-Java would not allow it anywhere else.

Note: If we do not explicitly write super() constructor, the JVM automatically inserts a call to the no-argument constructor of the superclass-unless we call a specific one with arguments.

• If the superclass does not have a no-arg constructor, we must use super() with parameters.
• We cannot use both this() and super() in the same constructor-they both need to be the first statement.

Example: Use of the super Keyword and super() Constructor

Output:

The cat is of color white
The cat is of color Brown
The eyes of the cat are blue.
Inside Main

Explanation

In the above example, we have defined Animal, Cat, and Main class. The Cat class extends the Animal class, and the Main class extends the Cat class. Inside the Main class, we have defined the Main class constructor as Main(). Inside the constructor, we have called the super() class constructor, which calls the constructor of its parent class, i.e., Cat.

When the second statement executes, the program's flow jumps to the Animal class to access the values of its data members. After accessing it, the flow returns to the Cat class constructor and prints the result. After that, the last statement executes and prints the value of the variables of the current class.

After execution of the last statement of the Cat class, the flow comes back to the constructor of the class Main and executes the remaining statements.

After completing the execution of the Main method, the flow comes back to the main() method and executes the remaining statements.

Note: In order to use the super(), we have to make sure that it is the first statement in the constructor of a class. We can use it to refer only to the parent class constructor.

Usages of the super Keyword

• Access Parent Class Variables: Super facilitates access to the parent class's variable when a child class contains a variable with the same name as its parent class.
• Call Parent Class Methods: Super permits calling the parent class's version of a method when a child class overrides one of its parent classes' methods.
• Invoke Parent Class Constructor: From a child class constructor, the parent class constructor can be called using super().
• Distinguish Between Members of the Parent and Child Classes: It is beneficial when members of the parent and child classes share the same name.
• Enhance Code Reusability: Rather than duplicating code in the child class, we can reuse parent class functionalities by employing super.

Differences Between this and super Keyword

The following table describes the key difference between this and super:

Differences Between this() and super() Constructor

Java this and super MCQs

1. In Java, this keyword refers to_______?

1. The superclass object
2. The current object
3. A static reference
4. A global variable

2. From the following statements, select the correct one about this() constructor call.

1. It can be used to call the superclass constructor
2. It can be used anywhere in the constructor
3. It must be the first statement in the constructor
4. It is used to exit from the constructor

3. In Java, the super keyword refers to_______?

1. The base interface
2. The current object
3. The superclass of the current object
4. A static method

4. Which of the following is not a valid usage of this keyword?

1. Invoking a method of the current class.
2. Invoking a constructor of the current class.
3. Passing itself as an argument to another method.
4. Referring to instance variables of the current class.

5. Which keyword is used to call the constructor of the superclass in a subclass constructor?

1. super
2. this
3. both
4. None of the above