Java – this keyword with example

May 18, 2016 SJ OOPS 1

In this article, we will discuss this keyword in Java

this keyword in java is used to refer the current instance of the class

1. Usage of this keyword in Java

  1. Instance variable: this keyword is used to refer the current instance variables of the class
  2. Class constructor: this() constructor call; is used to invoke other overloaded constructor of the same class
  3. Instance method: <methodName> is used to invoke current instance method of the same class
  4. Method parameter: this keyword can be used to pass as argument in method invocation
  5. Return type: this keyword can be used to return current class instance

Note: this cannot be used to refer anything in static context

Let us understand each one in detail with examples

1.1 this keyword with instance variables

  • this keyword helps to distinguish between local and instance variables, if their names are same
  • So, there arises 2 cases

1.1.1 When identifier-name of local-variable and instance-variable are same

Employee.java

package in.bench.resources.thiskeyword.example;

public class Employee {

	// instance-variables
	int empId;
	String empName;

	//	2-arg parameterized constructor
	Employee(int employeeId, String employeeName) {
		// warn: The assignment to variable empId has no effect
		employeeId = employeeId;
		// warn: The assignment to variable empName has no effect
		employeeName = employeeName;
	}

	// display() method to print employee info
	void displayEmployeeInfo() {
		System.out.print("Employee Id : " + empId);
		System.out.println("\tEmployee Name : " + empName);
	}

	// main() method - the entry point to JVM to begin execution
	public static void main(String[] args) {

		// creating object of type Employee
		Employee emp1 = new Employee(1001, "Rahul Dravid");
		Employee emp2 = new Employee(1002, "VVS Laxman");

		// invoking display() method using newly created objects
		emp1.displayEmployeeInfo();
		emp2.displayEmployeeInfo();
	}
}

Output:

Employee Id : 0	Employee Name : null
Employee Id : 0	Employee Name : null

Explanation:

  • Even after creating 2 objects of type Employee, when we invoked display() method to print employee details, it is printing default values for integer and string variables
  • Reason: Though, assignment is done we haven’t set the values for any specific instance
  • Note: Compiler warns with message “The assignment to variable <identifierName> has no effect”

Solution for above problem :

  • To overcome this problem we will use this keyword which will set the values for current referring instance
  • below example is exactly same as that of above example with changes in line no. 11 and 12
  • here, we are explicitly assigning current instance-variables to local-variables using this keyword

Employee.java

package in.bench.resources.thiskeyword.example;

public class Employee {

	// instance-variables
	int empId;
	String empName;

	//	2-arg parameterized constructor
	Employee(int empId, String empName) {
		this.empId = empId;
		this.empName = empName;
	}

	// display() method to print employee info
	void displayEmployeeInfo() {
		System.out.print("Employee Id : " + empId);
		System.out.println("\tEmployee Name : " + empName);
	}

	// main() method - the entry point to JVM to begin execution
	public static void main(String[] args) {

		// creating object of type Employee
		Employee emp1 = new Employee(1001, "Rahul Dravid");
		Employee emp2 = new Employee(1002, "VVS Laxman");

		// invoking display() method using newly created objects
		emp1.displayEmployeeInfo();
		emp2.displayEmployeeInfo();
	}
}

Output:

Employee Id : 1001	Employee Name : Rahul Dravid
Employee Id : 1002	Employee Name : VVS Laxman

Explanation:

  • With the use of this keyword, we are assigning instance-variable value with local-variable through constructor
  • Also, it is clear from output that values are printing in the console for respective instance variables i.e.; emp1 and emp2

1.1.2 When identifier name of local variable and instance variable are different

  • Variable Hiding: Earlier case is variable hiding scenario where local variable hides instance variables. So, to overcome this problem we have used this keyword
  • But, if identifier name of local variable and instance variable are different then there is no need of this keyword
  • Note: But the use of this keyword doesn’t affect/impact any assignment

Let us see an example on this case

Employee.java

package in.bench.resources.thiskeyword.example;

public class Employee {

	// instance variables
	int empId;
	String empName;

	//	2-arg parametrized constructor
	Employee(int eid, String eName) { 	// line no. 10
		empId = eid;				// line no. 11
		empName = eName;			// line no. 12
	}

	// display() method to print employee info
	void displayEmployeeInfo() {
		System.out.print("Employee Id : " + empId);
		System.out.println("\tEmployee Name : " + empName);
	}

	// main() method - the entry point to JVM to begin execution
	public static void main(String[] args) {

		// creating object of type Employee
		Employee emp1 = new Employee(1001, "Rahul Dravid");
		Employee emp2 = new Employee(1002, "VVS Laxman");

		// invoking display() method using newly created objects
		emp1.displayEmployeeInfo();
		emp2.displayEmployeeInfo();
	}
}

Output:

Employee Id : 1001	Employee Name : Rahul Dravid
Employee Id : 1002	Employee Name : VVS Laxman

Explanation:

  • Above program is same as that of earlier 2 programs with changes in line no. 10, 11 and 12

1.2 this() keyword with constructor

  • this() constructor call; is used to invoke another overloaded constructor in the same class
  • if overloaded constructor-1 is already doing some task, then another overloaded constructor-2 doesn’t neccessarily need to do same task again; instead invoke constructor using this() constructor call with necessary parameters
  • this() constructor call; helps in removing redundant code and better re-usability
  • if this() constructor call is present, then it must be first line of the constructor, otherwise compiler throws error
  • invoking one constructor from another constructor is known as constructor chaining in Java
  • Note: We can’t explicitly invoke another overloaded constructor, other than the use of this() constructor call

Read more about constructor overloading and constructor chaining here

Employee.java

package in.bench.resources.thiskeyword.example;

public class Employee {

	// instance variables
	int empId;
	String empName;

	// 1-arg parameterized constructor
	Employee(int empId) {
		this.empId = empId;
	}

	//	2-arg parametrized constructor
	Employee(int empId, String empName) {
		this(empId);
		this.empName = empName;
	}

	// display() method to print employee info
	void displayEmployeeInfo() {
		System.out.print("Employee Id : " + empId);
		System.out.println("\tEmployee Name : " + empName);
	}

	// main() method - the entry point to JVM to begin execution
	public static void main(String[] args) {

		// creating object of type Employee
		Employee emp1 = new Employee(1001, "Rahul Dravid");
		Employee emp2 = new Employee(1002, "VVS Laxman");

		// invoking display() method using newly created objects
		emp1.displayEmployeeInfo();
		emp2.displayEmployeeInfo();
	}
}

Output:

Employee Id : 1001	Employee Name : Rahul Dravid
Employee Id : 1002	Employee Name : VVS Laxman

Explanation:

  • We are creating 2 employee objects using 2-arg constructor which in turn invokes another overloaded 1-arg constructor (constructor chaining) using this() constructor call
  • Other things are similar as stated in the earlier example to display employee info

1.3 this keyword with method invocation of current class

Syntax: this.<method_Name>();

  • this keyword is used to invoke current class’s instance method invocation
  • Compiler inserts this keyword for current class’s method invocation, if not present in the method call

Employee.java

package in.bench.resources.thiskeyword.example;

public class Employee {

	// Method 1: displayEmployeeInfo() to print employee info
	void displayEmployeeInfo() {
		System.out.println("Displaying employee info");
	}

	// Method 2: display() for demo purpose
	void display() {
		System.out.println("Implicitly this keyword "
				+ "is inserted by compiler, if not present");
		// implicitly 'this' inserted by compiler - line no. 15
		this.displayEmployeeInfo();
	}

	// main() method - the entry point to JVM to begin execution
	public static void main(String[] args) {

		// creating object of type Employee
		Employee emp1 = new Employee();

		// invoking display() using object reference
		emp1.display();
	}
}

Output:

Implicitly 'this' is inserted by compiler, if not present
Displaying employee info

Explanation:

  • Instead of this.displayEmployeeInfo() // at line no. 15
  • We can simply put as displayEmployeeInfo() // at line no. 15 as this keyword is inserted during compilation process by compiler

1.4 this keyword with method parameter

  • this keyword can be used to pass as argument in method invocation

Employee.java

package in.bench.resources.thiskeyword.example;

public class Employee {

	// instance variable
	String empName;

	// 1-arg parametrized constructor
	Employee(String empName) {
		this.empName = empName;
	}

	// Method 2: displayEmployeeInfo() method to print emp-info
	void displayEmployeeInfo(Employee employee) {
		System.out.println("Employee Name : " + employee.empName);
	}

	// Method 1: display() method for demo purpose
	void display() {
		displayEmployeeInfo(this);
	}

	// main() method - the entry point to JVM to begin execution
	public static void main(String[] args) {

		// creating object of type Employee
		Employee emp1 = new Employee("Rahul Dravid");
		emp1.display();
	}
}

Output:

Employee Name : Rahul Dravid

Explanation:

  • While invoking a method with Employee object we are explicitly passing this which indicates the current instance
  • So, it is one of the way to pass method parameter using this for current instance

1.5 this keyword with return-type

  • Return type :- this keyword can be used to return current class’ instance
  • Note :- To return this keyword (current instance) from method, we need to have return-type as current class-type; otherwise it won’t work
  • Syntax:
return_type method_name() {
       return this;
}

Employee.java

package in.bench.resources.thiskeyword.example;

public class Employee {

	// instance variable
	String empName;

	// Method 1: getEmployeeInfo() method to return using this
	Employee getEmployeeInfo() {
		this.empName = "VVS Laxman";
		return this;
	}

	// main() method - the entry point to JVM to begin execution
	public static void main(String[] args) {

		// creating object of type Employee
		Employee emp1 = new Employee();
		emp1.getEmployeeInfo();

		// printing employee name into console
		System.out.println("Employee Name : " + emp1.empName);
	}
}

Output:

Employee Name : VVS Laxman

Explanation:

  • We are returning this as return value
  • But before that, we are setting employee name using this keyword
  • finally when control return back, we are printing employee-name in the console
  • So, this can be used to return type

2. Point to remember about this keyword:

  • this is used to refer current class’s instance
  • this can be used to refer instance-variable of same class
  • this() constructor call; is used to invoke another overloaded constructor using this keyword in the same class
  • this keyword is used to invoke instance-method of the same class
  • this can be used as method-argument, when invoking method
  • this can be used to return-value from instance-method, provided return-type of method is current class’ type
  • this can be used in constructor-call, while invoking overloaded constructor

That’s all about this keyword in Java

Related Articles:

References:

Happy Coding !!
Happy Learning !!

Java - super keyword with example
Java - static keyword with example

Related posts:

  1. Java – instanceof operator or keyword
  2. Java – final keyword with example
  3. Java – Interview Question and Answers on final keyword
  4. Java – static keyword with example