Other usage of the this keyword in Java

(For those who read my previous question, this is the same teacher and the same project.)

My teacher 'inspected' my code for a web application project and provided some suggestions. One of the suggestions was to use the this keyword even in this situation:

private String getUsername() {
    return username;
}

So if I follow his advice, that would become:

private String getUsername() {
    return this.username;
}

I asked him why and he told me that there is another usage for the this keyword other than for clearing up ambiguities. A quick googling returned no res开发者_JS百科ults for another usage of the this keyword. Even the Java tutorial from Sun mentioned no other usages that would fit in this situation.

this also allows you access to the surrounding class instance and its members from within a nested class, e.g.

public class OuterClass
{
    private class InnerClass
    {
        public OuterClass getOuter()
        {
            return OuterClass.this;
        }
    }
}

You use it to chain constructors as well:

public class Foo
{
    private final String name;

    public Foo()
    {
        this("Fred");
    }

    public Foo(string name)
    {
        this.name = name;
    }
}

(For chaining to a superclass constructor, use super(...).)

Additionally, there are some weird times where you can use it from an inner class to specify exactly which member you're after. I don't remember the exact syntax, fortunately - I don't need to use it often.

An very important one that hasn't been mentionned, is the use of this for method chaining used in fluent APIs. In this design pattern, all methods return this, regardless of what they do, allowing you to so stuff like:

dog.setColor("black").setSize("tall").makeDangerous().bark();

using an API constructed, so:

public Dog setColor(String c) {
    color=c;
    return this;
    }

Some people think it is good practice to always use the keyword this for class fields. This can be useful in the following situation:

class MyClass {
    private int x = 0;

    public void DoSomething(int x) {
        int privateFieldValue = this.x; // use field of our class
    }
}

Also, you can return this to chain method calls - e.g. in Builder pattern.

class CustomerBuilder
{
    private String firstName = "Default";
    private String lastName = "Default";

    public CustomerBuilder setFirstName(String firstName)
    {
        this.firstName = firstName;
        return this;
    }

    public CustomerBuilder setLastName(String lastName)
    {
        this. lastName = lastName;
        return this;
    }

    public Customer build()
    {
        /* ... do some actions to build a Customer object ... */
    }
}

Then, you can use this builder like this:

Customer customer = new CustomerBuilder().setFirstName("John").setLastName("Smith").build();

Always accessing member variables using this. is a coding convention in some places. The idea is probably that it's similar to naming conventions ("All field names must start with an underscore _") but without the ugly name-mangling. (Other places have exactly the opposite convention: avoiding this. unless absolutely necessary).

Personally I don't see any real reason to do it, since all tools you use to access your code should be able to color/style-code each variable/field to make the distinction.

Your grand-dads text-editor is not able to show the difference between accessing a local variable and a field. But that's not a good reason for hard-coding it redundantly in your code.

There is no other usage of the 'this' except for calling another constructor of the same class.

Qualifying access to member variables - even if not needed - is considered best-practice by some developers (I don't). The main point is that it is possible to change the semantics of an assignment without changing that line:

class Foo {

  String foo;

  void foo() {
    // a lot of code
    foo = "something"
  }

}

May be changed by simply doing the following:

  void foo() {
    String foo;
    // a lot of code
    foo = "something"
  }

So it's mostly about maintenance and readability - for the price of verbosity.

Using the this keyword will also trigger a warning from the compiler if someone comes along and decides to change the username member to a static variable on you. If you don't use this, the compiler will just play along like everything is cool. And username changing to be static could very well be a bug. So you probably want the warning. And if it isn't a bug, you should change the code that uses username to treat it as if it is static to avoid future bugs / misunderstandings in the code. That way, if someone comes along and changes it back you'll get a new warning.

So, if nothing else, in the context of a getter, it can also trigger compiler warnings when other things change on you. And that is a Good Thing.