In this tutorial, you will learn the keyword this in Java. An example will help you learn how and where to use it.

This keyword

In Java, this refers to the current object in methods or constructs. Let’s give an example to prove it.

1. class MyClass {
2. int instVar;
3. MyClass (int instVar) {
4. this.instVar = instVar;
5. System.out.println (“this reference =” + this);
6. }
7. public static void main (String [] args) {
8. MyClass obj = new MyClass (8);
9. System.out.println (“object reference =” + obj);
10. }
11. }

Output

this reference = com.ThisAndThat.MyClass@74a14482

object reference = com.ThisAndThat.MyClass@74a14482

Note that the obj and this object identifiers are the same. This means nothing more than referring to the current object.

There are three situations in which this keyword is commonly used.

1. Use this to separate different variable sources

In Java, you cannot define two or more variables with the same name in a domain (class domain or method domain). However, the sample variables and parameters may have the same name. As:

class MyClass {

int instVar; // instVar instance variable

MyClass (int instVar) {// instVar parameter

instVar = instVar;

}

}

The Java compiler is mistaken in the above program due to the ambiguous names. Therefore, to solve this problem, the keyword this is used.

Let’s look at an example without using this keyword:

1. class MyClass {
2. int instVar;
3. MyClass (int instVar) {
4. instVar = instVar;
5. }
6. public static void main (String [] args) {
7. MyClass mc = new MyClass (8);
8. System.out.println (“mc.instVar =” + mc.instVar);
9. }
10. }

Output

mc.instVar = 0

You might expect the output to be 8. Still, instead, it printed zero because the Java compiler made a mistake due to the name ambiguity between the sample variable and the constructor parameter.

Let’s rewrite the above code and use this keyword to solve this problem.

1. class MyClass {
2. int instVar;
3. MyClass (int instVar) {
4. this.instVar = instVar;
5. }
6. public static void main (String [] args) {
7. MyClass obj = new MyClass (8);
8. System.out.println (“obj.instVar =” + obj.instVar);
9. }
10. }

Output

mc.instVar = 8

You will now get the expected output. When you create an object, the Java compiler knows which object the constructor used.

When the Java compiler calls the constructor, the object that called the constructor replaces it inside the constructor.

Note: If you submit a parameter with a different name than the sample variables, the compiler will automatically attach this keyword.

This code

class MyClass {

int instVar;

MyClass (int i) {

instVar = i;

}

}

It is equal to:

class MyClass {

int instVar;

MyClass (int i) {

this.instVar = i;

}

}

Another everyday use of this keyword is in a class’s get and set methods. For example:

1. class POJO {
2. String name;
3. void setName (String name) {
4. this.name = name;
5. }
6. String getName () {
7. return this.name;
8. }
9. public static void main (String [] args) {
10. POJO pojo = new POJO ();
11. pojo.setName (“Toshiba”);
12. System.out.println (“pojo.name:” + pojo.getName ());
13. }
14. }

Output

pojo.name: Toshiba

2- Using this in overloading manufacturers

When working with builders overloading, calling one builder over another may be more useful. However, the creators can not be explicitly called. Therefore, you can use another form of this keyword to achieve this goal. (() this)

The pseudo-code is shown here:

this (arg-list)

Here’s how to use this in the manufacturer’s call.

1. class Complex {
2. private int a, b;
3. // parameterize constructor
4. private Complex (int i, int j) {
5. this.a = i;
6. this.b = j;
7. }
8. private Complex (int i) {
9. this (i, i); // invokes Complex (int i, int j);
10. }
11. private Complex () {
12. this (0); // invokes Complex (int i);
13. }
14. @Override
15. public String toString () {
16. return this.a + ”+” + this.b + “i”;
17. }
18. public static void main (String [] args) {
19. Complex c1 = new Complex (2, 3);
20. Complex c2 = new Complex (3);
21. Complex c3 = new Complex ();
22. System.out.println (c1);
23. System.out.println (c2);
24. System.out.println (c3);
25. }
26. }

Output

2 + 3i

3 + 3i

0 + 0i

In the above program, it does not matter which constructor is called when introducing the object, finally the parametric constructor is called.

Be careful when using this (). Constructors calling this () run slowly because calling an additional constructor adds another overhead. If your class is only used to create a handful of objects, using this () is useful. Another great advantage of using this () is reducing duplicate code.

3- Send this as an argument

You can use this if you need to move the current object as an argument to a method.

1. class ThisExample {
2. int x;
3. int y;
4. ThisExample (int x, int y) {
5. this.x = x;
6. this.y = y;
7. System.out.println (“Before passing this to addTwo () method:”);
8. System.out.println (“x =” + this.x + “, y =” + this.y);
9. addTwo (this);
10. System.out.println (“After passing this to addTwo () method:”);
11. System.out.println (“x =” + this.x + “, y =” + this.y);
12. }
13. void addTwo (ThisExample o) {
14. ox + = 2;
15. oy + = 2;
16. }
17. }
18. class Demo {
19. public static void main (String [] args) {
20. ThisExample obj = new ThisExample (1, -2);
21. }
22. }

Output

Before passing this to addTwo () method:

x = 1, y = -2

After passing this to addTwo () method:

x = 3, y = 0

Here, the addTwo () method is called with this as an argument from within the constructor.