this Keyword in Java

Last Updated on November 30, 2023 by Ankit Kochar

In Java, the "this" keyword is a fundamental element that plays a crucial role in object-oriented programming. It is used to refer to the current instance of the class in which it appears. The "this" keyword is particularly useful in scenarios where there is a need to differentiate between instance variables and parameters with the same name within a class. This introduction delves into the significance and usage of the "this" keyword in Java, highlighting how it helps maintain clarity and precision in object-oriented code.

Keywords in Java

As previously noted, the Java programming language includes a collection of predefined keywords. These specific keywords hold distinct meanings, and they are restricted from being utilized as identifiers or variable names within a Java program.

Some commonly used keywords in java are:

• abstract
• boolean
• break
• byte
• case
• catch
• long
• while
• protected
• return
• short
• public
• new
• this
• interface

Now let us delve deeper and learn about the this keyword in java.

this Keyword in Java

In Java, the "this" keyword refers to the current object of a class. It is used to refer to a class’s current instance variable. It may also be used to call a function constructor of a class from another constructor of the same class.

Every object in Java has a reference to itself, which may be retrieved with the "this" keyword. When you use "this" in a method, it refers to the class’s instance variable, not the method’s local variable. This makes it easy to distinguish between a class’s instance variables and local variables.

Examples Demonstrating the use of this Keyword in Java

Let’s take a look at some examples demonstrating the use of this keyword in Java.

Example 1 of use of this Keyword in Java
Using this keyword in Java to access the instance variables.

Code:

class Person {
   private String name;
   private int age;


   public Person(String name, int age) {
       this.name = name;
       this.age = age;
   }


   public void printDetails() {
       System.out.println("Name: " + this.name);
       System.out.println("Age: " + this.age);
   }
}


class Main{
  public static void main(String args[]){
     Person person = new Person("PrepBuddy", 18);
     person.printDetails();
  }
}

Output:

Name: PrepBuddy
Age: 18

Explanation:
In the above code, in printDetails() method, we use this keyword in java to access the name and age instance variables of the current Person object. This is necessary because the method has its own name and age parameters that would otherwise shadow the instance variables.

Example 2 of use of this Keyword in Java
Using this Keyword in Java to invoke another constructor in the same class.

Code:

class Rectangle {
   private int width;
   private int height;


   public Rectangle(int sideLength) {
       this(sideLength, sideLength);
   }


   public Rectangle(int width, int height) {
       this.width = width;
       this.height = height;
   }


   public int getArea() {
       return this.width * this.height;
   }
}


public class Main{
  public static void main (String args[]){
     Rectangle square = new Rectangle(45);
     System.out.println("Area of square: " + square.getArea());
     
     Rectangle rectangle = new Rectangle(4, 15);
     System.out.println("Area of rectangle: " + rectangle.getArea());
  }
}

Output:

Area of square: 2025
Area of rectangle: 60

Explanation:
The Rectangle class has two constructors, one that takes a single argument for a square and another that takes separate arguments for width and height. In the constructor that takes a single argument, we use this to call the other constructor with the same width and height. This avoids duplicating the initialization code for the width and height instance variables.

Example 3 of use of this Keyword in Java
Using this Keyword in Java to pass the current object as an argument to another method.

Code:

class BankAccount {
   private double balance;


   public BankAccount(double balance) {
       this.balance = balance;
   }


   public void deposit(double amount) {
       this.balance += amount;
       System.out.println("Deposited " + amount + ", new balance is " + this.balance);
   }


   public void transfer(BankAccount otherAccount, double amount) {
       this.balance -= amount;
       otherAccount.deposit(amount);
       System.out.println("Transferred " + amount + " from this account to other account");
   }
}


public class Main{
  public static void main(String args[]){
     BankAccount account1 = new BankAccount(5467);
     BankAccount account2 = new BankAccount(556);
     account1.transfer(account2, 444);
  }
}

Output:

Deposited 444.0, new balance is 1000.0
Transferred 444.0 from this account to other account

Explanation:
The transfer() method takes another BankAccount object and a double amount as arguments and transfers the specified amount from this account to the other account. We use this to refer to the current object instance when calling the deposit() method on the other account, passing the current account’s balance as the deposit amount. This way, the deposit amount is added to the other account’s balance and subtracted from the current account’s balance.

Example 4 of use of this Keyword in Java
Using this Keyword in Java to return the current object from a method.

Code:

class Car {
   private String make;
   private String model;


   public Car(String make, String model) {
       this.make = make;
       this.model = model;
   }


   public Car withMake(String make) {
       this.make = make;
       return this;
   }


   public Car withModel(String model) {
       this.model = model;
       return this;
   }


   public String toString() {
       return this.make + " " + this.model;
   }
}


class Main{
  public static void main(String args[]){
     Car car = new Car("Toyota", "Camry");
     car.withMake("Honda").withModel("Accord");
     System.out.println(car.toString());
  }
}

Output:

Honda Accord

Explanation:
The Car class has two methods, withMake() and withModel(), that modify the make and model instance variables respectively and return the current object instance. This allows us to chain these method calls together to set multiple properties of the object in a single statement. We use this to return the current object instance from these methods, making it easy to chain them together.

Example 5 of use of this Keyword in Java
Using this Keyword in Java to call an instance method from another instance method.

Code:

class Calculator {
   private double result;


   public Calculator() {
       this.result = 0;
   }


   public void add(double value) {
       this.result += value;
   }


   public void subtract(double value) {
       this.result -= value;
   }


   public void multiply(double value) {
       this.result *= value;
   }


   public void divide(double value) {
       if (value == 0) {
           throw new IllegalArgumentException("Division by zero");
       }
       this.result /= value;
   }


   public void clear() {
       this.result = 0;
   }


   public double getResult() {
       return this.result;
   }


   public void calculate(double value1, char operator, double value2) {
       switch (operator) {
           case '+':
               this.add(value2);
               break;
           case '-':
               this.subtract(value2);
               break;
           case '*':
               this.multiply(value2);
               break;
           case '/':
               this.divide(value2);
               break;
           default:
               throw new IllegalArgumentException("Invalid operator: " + operator);
       }
   }
}


class Main{
  public static void main(String args[]){
     Calculator calculator = new Calculator();
     
     calculator.calculate(10, '+', 5);
     System.out.println("Result: " + calculator.getResult());
     
     calculator.calculate(15, '*', 2);
     System.out.println("Result: " + calculator.getResult());
  }
}

Output:

Result: 15.0
Result: 30.0

Explanation:
The Calculator class has several methods for performing basic arithmetic operations and maintaining a current result. The calculate() method takes two operands and an operator as arguments, and performs the specified operation on the current result using one of the other instance methods. We use this to call these methods on the current object instance.

Benefits of using this Keyword in Java

Some of the benefits of this Keyword in Java are listed below.

• Avoiding name Conflicts: Many a time, the parameter passed in the constructor have the same name as that of an instance variable already present in the class. Here, the this keyword helps the programmer in avoiding the name conflicts between the two.
• Improving readability: The this keyword in Java helps the programmer in making the code more readable and easier to understand especially when working with complex class hierarchies.
• Enhancing code reusability: Using "this" to call another constructor in the same class can reduce code duplication and improve code reusability.
• Improving encapsulation: Using "this" to refer to instance variables instead of local variables can improve encapsulation and prevent accidental modifications to the wrong variable.

Conclusion
In conclusion, the "this" keyword in Java serves as a valuable tool for object-oriented programming, allowing developers to distinguish between instance variables and method parameters effectively. Its usage contributes to code clarity, making it easier to understand and maintain. By explicitly referring to the current instance of a class, the "this" keyword enhances the precision of Java code, particularly in situations where variable names overlap. Understanding and using "this" appropriately is a key aspect of writing clean and readable Java programs.

Frequently Asked Questions (FAQs) related to this keyword in Java

Here are some frequently asked questions on this keyword in Java.

Q1: When should I use the "this" keyword in Java?
A1: The "this" keyword is used in Java to refer to the current instance of a class. It is particularly helpful when there is a need to distinguish between instance variables and method parameters that share the same name within a class.

Q2: Can "this" be used in static methods in Java?
A2: No, the "this" keyword cannot be used in static methods in Java because static methods are associated with the class itself rather than a specific instance.

Q3: How does "this" contribute to code clarity in Java?
A3: "this" improves code clarity by explicitly indicating that a variable or method belongs to the current instance of the class. This distinction is valuable in scenarios where instance variables and parameters have the same name.

Q4: Can "this" be used outside of constructors and methods?
A4: Yes, "this" can be used outside of constructors and methods in Java. It can be used in instance initializer blocks and, more rarely, in nested class instances to refer to the current instance.

Q5: What happens if "this" is not used when there’s a naming conflict?
A5: If "this" is not used in a situation where there is a naming conflict, the compiler will assume the reference to be the closest scope. Using "this" explicitly resolves the ambiguity and ensures the correct reference to the instance variable.