Thread: What is the use of "this." and implicit parameters?

I feel that I understand the uses of *this* in Java programs, but for the life of me find it to be one of the hardest concepts to discuss with other people, that it is perhaps more abstract than other Java concepts,... but despite that, here goes another attempt.

Inside of your class, *this* refers to the current object of the class the one whose code is currently being run. For instance, say you have a class called Foo:

public class Foo {
  private int bar;
 
  public Foo(int bar) {
    this.bar = bar;  // line (A)
  }
  public void someMethod() {
     System.out.println("bar is " + this.bar); // line (B)
  }
}

if later you use this class to create a few objects:

public class Baz {
  public static void main(String[] args) {
    Foo foo1 = new Foo(3);  // line (C)
    Foo foo2 = new Foo(5);  // line (D)
 
    foo1.someMethod();  // line (E)
    foo2.someMethod();  // line (F)
  }
}

On line (C) you create a new Foo object and have foo1 refer to it. When the constructor is called the *this* inside of the constructor on line (A) will refer to the current object being constructed, foo1. So the bar variable being dereferenced on this object will be foo1's bar variable. On the other hand when line (D) is reached, *this* will refer to the foo2 Foo object that is being constructed, and the this.bar variable will be foo2's bar. So while it's the same Foo class for both, but the *this* only refers to the current object that controls the class's code at that time (understand that foo1 and foo2 share the exact same code).

Likewise on line (E), when foo1 calls someMethod, the *this* inside of someMethod on line (B) refers to the foo1 object, and will return 3, while on line (F), the *this* in this method will refer to foo2 and will return 5.

Note that since the Foo constructor's parameter, bar, and the class field, bar, have the same name, the *this* in the constructor on line (A) is required so the compiler will know which bar you're mean to refer to, the bar variable defined in the constructor's parameter (which gets no *this* before it), or the bar variable declared in the class (which requires the *this* in front of it). If you gave the parameter a different variable name, then no this. would be needed since it would be clear to the compiler which variable you mean to use always.

Note that the *this* used in line (B) is not needed since it is already "implicitly" present when using the variables of the class.

Clear as Mudd?

Some clarification of the above, again this bit of code:

  public void someMethod() {
     System.out.println("bar is " + this.bar); // line (B)
  }

is equivalent to

  public void someMethod() {
     System.out.println("bar is " + bar); // line (B)
  }

Since there is no confusion as to which *bar* this is since the method has no parameter or local variable by the same name, then the *this.* part is not required as it is implicitly present and does not need to be explicitly written.

Also, other uses for *this*:

• In a constructor, *this* can allow the constructor to call other constructor overloads of the same class. e.g.
  
  public class Foo {
    private int i;
    private String text;
    public Foo(int i) {
      this.i = i;
      text = "";
    }
   
    public Foo(int i, String text){
      this(i); // *** here!!! ***
      this.text = text;
    }
  }

• The identifier *this* can be used when trying to clarify which object you're referring to when you are inside a non-static inner class. i.e., MyOuterClass.this.someMethodOfOuterClass()
• .... and I'm sure that there's more that I've forgotten, but hopefully the forum gurus will fill the rest in!