if you save your file as test.pde you can do something like this

1.  int variable = 1;
2. void setup() {
3.   Object object = new Object();
4.   object.function();
5. }
6. class Object {
7.   int variable = 2;
8.  
9.   Object() {
10.    
11.   }
12.  
13.   void function() {
14.        print(this.variable);
        print(new test().variable); //or better, declare variable=1 static and call it like this:    test.variable
    
15.    
16.   }
17. }

this allows to distinguish class fields (variables) from parameters, for example. It has other usages, like passing a reference of the current instance as parameter to a function, but that's the main usage.
Example:
void foo(int x, int y)
{
  this.x = x;
  this.y = y;
}
Here, it isn't bad practice, it is even a common idiom. Personally, I generally avoid to use this, just using different names.

Just an extra clarification:

It doesn't need necessarily to be "parameter"-created variables, like PhiLho's example.
Rather any local variables are valid to be distinguished from class vars. w/ same name by using of this before class typed ones.
That is so b/c variables created to receive passed parameters are themselves local variables as well!  

class Test {

    int var = 5;

    void test() {

        int var   = 10;    // local var. created & initialized
        this.var += 20;    // class var. referenced here instead

        println(var);
        println(this.var);
    }
}

final Test myTest = new Test();

void setup() {

    noLoop();

    myTest.test();
}

Thanks for the clarification, I was vaguely thinking of other usages but felt short (it was late...).
Now, there is the same issue: why use same names?
But it isn't really a technical question, so your point is still good.
Again, parameters is the most commonly use case: giving them the same name is kind of auto-documentation.