Using "this" with methods (in Java)

Question

what about using "this" with methods in Java? Is it optional or there are situations when one needs to use it obligatory?

The only situation I have encountered is when in the class you invoke a method within a method. But it is optional. Here is a silly example just to show what I mean:

public class Test {

    String s;

    private String hey() {
        return s;
    }

    public String getS(){
        String sm = this.hey();
        // here I could just write hey(); without this
        return sm;
    }
}

Answer 1

Three obvious situations where you need it:

• Calling another constructor in the same class as the first part of your constructor
• Differentiating between a local variable and an instance variable (whether in the constructor or any other method)
• Passing a reference to the current object to another method

Here's an example of all three:

public class Test
{
    int x;

    public Test(int x)
    {
        this.x = x;
    }

    public Test()
    {
        this(10);
    }

    public void foo()
    {
        Helper.doSomethingWith(this);
    }

    public void setX(int x)
    {
        this.x = x;
    }
}

I believe there are also some weird situations using inner classes where you need super.this.x but they should be avoided as hugely obscure, IMO :)

EDIT: I can't think of any examples why you'd want it for a straight this.foo() method call.

EDIT: saua contributed this on the matter of obscure inner class examples:

I think the obscure case is: OuterClass.this.foo() when accessing foo() of the outer class from the code in an Inner class that has a foo() method as well.

Answer 2

I use "this" to clarify code, often as a hint that I'm calling an instance method rather than accessing a class-level method or a field.

But no. Unless disambiguation is required due to scope naming collision, you don't actually need "this."

Answer 3

For most general programing, the this keyword is optional and generally used to avoid confusion. However, there are a few places where it is needed.

class Foo {
    int val;

    public Foo(int val) {
         this(val, 0);  //this MUST be here to refer to another constructor
    }

    public Foo(int val, int another) {
        val = val;       //this will work, but it generally not recommended.
        this.val = val;  //both are the same, but this is more useful.
        method1();       //in a Foo instance, it will refer to this.method1()
        this.method1();  //but in a Foo2 instance, you must use this to do the same
    }

    public void method1() {}
}

class Foo2 extends Foo {
    public Foo2(int val) {
        this(val);        //this will refer to the other Foo2 constructor
    }
    public Foo2(int val, int another) {
        super(val, another);
        super.method1();   //this will refer to Foo.method1()
    }

    @Override
    public void method1() {}//overridden method
}

These are not all the cases, but some of the more general ones. I hope this helps you better understand the this and super keywords and how/when to use them.

Answer 4

The only reason to prepend this in front of a method invocation is to indicate that you're calling a non-static method. I can't think of any other valid reason to do this (correct me I'm wrong). I don't recommend this convention as it doesn't add much value. If not applied consistently then it could be misleading (as a this-less method invocation could still be a non-static method). How often does one care if the method being invoked is static or not? Furthermore, most IDEs will highlight static methods differently.

I have heard of conventions where this indicates calling the subclass's method while an absence of this is calling the super class's method. But this is just silly as the convention could be the other way around.

Edit: As mmyers points out (see comment), this works with static methods. With that, I see absolutely no reason to prepend with this as it doesn't make any difference.

Answer 5

The only time it is really required is when you have a parameter to a method with the same name as a member variable. Personally, I try to always use it to make the scope of the variable/method explicit. For example you could have a static method or an instance method. When reading the code it can be helpful to know which is which.

Answer 6

Not an answer (so feel free to vote it down), but I couldn't fit this into a comment where someone was asking.

A lot of people use "this.x" to visually differentiate instance variables from local variables and parameters.

So they would do this:

private int sum;
public int storeSquare (int b) {
    int c=b*b;
    this.sum+=c; // Makes sum "pop" I guess
    return c;
}

Personally I think it's a bad habit: any usable editor will put instance and local variables in a different color for you reliably--it doesn't require any human-fallible patterns.

Doing it with "this." is only 50% safe. Sure the compiler will catch it if you try to put this.x when x is a local variable, but there is nothing that is going to stop you from "Forgetting" to tag an instance variable with this., and if you forget to tag just one (or if someone else works on your code) and you are relying on the pattern, then the pattern may be more damaging than good

Personally I'm fairly sure the pattern stems from programmers (rightful) discomfort with the fact that in this case:

public void setMe(int me) {
    this.me=me;
}

the fact that you need "this." in front of the me is determined by the name of the parameter--I agree it just feels sloppy. You want to be consistent--if you need this. in front of the me there, why not always use it?

Although I understand the discomfort, typing this. every single place that an instance variable is used is just pedantic, pointless, ugly and unreliable. If it really bothers you and you absolutely need to use a pattern to solve it, try the habit of putting "p" in front of your parameters. As a side effect, it should even make it more constant because the parameter case will now match the method case..

public void setMe( int pMe) 

Answer 7

http://java.sun.com/j2se/1.5.0/docs/api/java/lang/StringBuilder.html

You absolutely need this if your method needs to return the object's instance.

public class StringBuildable {
    public StringBuildable append(String text) {
        // Code to insert the string -- previously this.internalAppend(text);
        return this;
    }
}

This allows you to chain methods together in the following fashion:

String string = new StringBuildable()
    .append("hello")
    .append(' ')
    .append.("World")
    .toString()
;