Related Articles
When diving into Java programming, you’ll quickly encounter the this and super keywords. Both are fundamental to understanding how objects and classes interact in Java’s object-oriented programming (OOP) paradigm. But what exactly do they do, and when should you use one over the other? Let’s break it down in simple terms.
What is the this Keyword in Java?
Definition of this Keyword
In Java, the this keyword refers to the current instance of the class in which you’re working. Whenever you need to refer to the current object of a class, you use this. It’s a bit like pointing a finger at yourself when talking about something specific to you.
Common Use Cases for this
1. Differentiating Between Instance Variables and Parameters
One of the most common uses of the This keyword in Java is to resolve ambiguity when local variables or method parameters have the same name as instance variables (class fields).
For example:
class Student {
String name;
Student(String name) {
this.name = name; // 'this' refers to the instance variable, not the parameter
}
}
Here, this.name refers to the instance variable, while name refers to the constructor’s parameter. Without this, Java would be confused about which “name” you’re referring to.
2. Calling Other Constructors
Another handy use of this is constructor chaining, where one constructor calls another constructor in the same class to avoid code duplication.
class Student {
String name;
int age;
Student(String name) {
this(name, 18); // Calling another constructor in the same class
}
Student(String name, int age) {
this.name = name;
this.age = age;
}
}
Here, the this(name, 18) calls the second constructor, reducing the amount of code you need to write.
Practical Example of Using this in Java
class Employee {
String name;
double salary;
Employee(String name, double salary) {
this.name = name; // 'this' refers to the instance variable
this.salary = salary;
}
void display() {
System.out.println("Employee Name: " + this.name);
System.out.println("Employee Salary: " + this.salary);
}
}
In this example, this.name and this.salary help refer to the current object’s properties, making it clear what is being accessed.
What is the super Keyword in Java?
Definition of super Keyword
The Super keyword in Java is used to refer to the immediate parent class of the current object. Whenever you need to access something from a parent class—like a method, variable, or constructor—super comes into play. It’s like calling your parent for help when you need something from them!
Common Use Cases for super
1. Calling Parent Class Constructor
The most common use of super is to call the parent class’s constructor from a subclass. This is particularly useful in inheritance when you need to initialize the parent class’s properties.
class Animal {
Animal() {
System.out.println("Animal constructor called");
}
}
class Dog extends Animal {
Dog() {
super(); // Calls the constructor of the parent class (Animal)
System.out.println("Dog constructor called");
}
}
In this case, super() ensures that the parent class’s constructor is called first before the subclass’s constructor.
2. Accessing Parent Class Methods and Variables
You can also use super to call methods or access variables that are inherited from the parent class but are hidden by the subclass.
class Animal {
void sound() {
System.out.println("Animal makes sound");
}
}
class Dog extends Animal {
void sound() {
super.sound(); // Calls the parent class method
System.out.println("Dog barks");
}
}
Here, the super.sound() ensures that the Animal class’s sound() method is called before executing the Dog class’s method.
Read More: Why .NET 8 is a Game-Changer for Modern Software Development
Practical Example of Using super in Java
class Vehicle {
String brand = "Ford";
void start() {
System.out.println("Vehicle is starting");
}
}
class Car extends Vehicle {
String brand = "Tesla";
void display() {
System.out.println("Car Brand: " + super.brand); // Access parent class variable
super.start(); // Call parent class method
System.out.println("Car is moving");
}
}
In this example, super.brand accesses the Vehicle class’s brand, and super.start() calls the parent class’s start() method.
Key Differences Between this and super in Java
1. Scope of Usage
thisrefers to the current instance of the class you’re working in.superrefers to the immediate parent class of the current instance.
2. Constructor Chaining
this()is used to call another constructor in the same class.super()is used to call the parent class’s constructor.
3. Accessing Methods and Variables
thisaccesses methods and variables of the current class.superaccesses methods and variables from the parent class, even if they are overridden in the current class.
4. Order of Invocation
In a class hierarchy, the parent class’s constructor is always called first, either implicitly or explicitly using super(). This is why when you’re working with inheritance, you may see the parent class being initialized before the subclass.
When to Use this and When to Use super
When to Use this
You’ll use this keyword in Java when you’re working with the current object. Whether it’s to resolve ambiguity in constructors or to invoke methods and variables of the current instance, this is all about the object you’re working on right now.
When to Use super
Use super keyword in Java When you’re dealing with inheritance, you need to interact with the parent class. Whether it’s calling the parent constructor or accessing hidden variables, super ensures you can tap into the parent class’s functionality.
Read More: Harnessing Big Data with Surfing Tech’s Expertise
Code Example: Combining this and super in Java
class Parent {
Parent() {
System.out.println("Parent constructor");
}
void show() {
System.out.println("Parent class method");
}
}
class Child extends Parent {
Child() {
this("Hello from Child"); // Calls another constructor in the same class
System.out.println("Child constructor");
}
Child(String message) {
super(); // Calls Parent constructor
System.out.println(message);
}
void display() {
super.show(); // Calls Parent class method
System.out.println("Child class method");
}
}
public class Main {
public static void main(String[] args) {
Child child = new Child();
child.display();
}
}
In this example, both this and super are used to demonstrate how you can work with constructors and methods across different levels in an inheritance hierarchy.
Common Interview Questions Related to this and super in Java
- What is the purpose of the
thiskeyword in Java?- The
thiskeyword refers to the current object of the class.
- The
- When do we use
super()in a constructor?- We use
super()in a subclass constructor to call the parent class constructor.
- We use
- Can
thisandsuperbe used together?- Yes,
thisandsupercan be used together but must follow specific rules. For example,this()andsuper()cannot be called simultaneously in the duplicate constructor.
- Yes,
- What happens if you don’t call
super()in a subclass constructor?- If
super()isn’t explicitly called, the compiler automatically inserts a call to the parent’s default constructor.
- If
- What’s the difference between
this.variableandsuper.variable?this.variableaccesses the current class’s variable whilesuper.variableaccesses the parent class’s variable.
Conclusion
Understanding the this keywords in Java and the super keyword in Java is crucial for mastering object-oriented programming, especially when dealing with inheritance and constructor chaining. These keywords play vital roles in ensuring your code is clear, maintainable, and behaves as expected. Next time you’re coding in Java, remember these keywords to make your code more structured and efficient!
