Possible Duplicate:
When should I use “this” in a class?
How does one know whether to use "this" when referring to a field of an instance?
for example:
return this.name
i was taught one case where it is useful. i.e. when an input parameter is the same as the field's name:
public void setName(String name) {
this.name = name;
}
Other than that, "this" seems unneeded.. What are some other cases?
When you have too many constructors for a class , you can use this to call other constructors. Example :
public class TeleScopePattern {
private final int servingSize;
private final int servings;
private final int calories;
private final int fat;
public TeleScopePattern(int servingSize, int servings) {
this(servingSize, servings, 0);
}
public TeleScopePattern(int servingSize, int servings, int calories) {
this(servingSize, servings, calories, 0);
}
public TeleScopePattern(int servingSize, int servings, int calories, int fat) {
this.servingSize = servingSize;
this.servings = servings;
this.calories = calories;
this.fat = fat;
}
}
You have to use this in a few cases:
when you have the same names of a field and a method parameter/local variable and you want to read/write the field
when you want to get access to a field of an outer class from an inner class:
class Outer {
private String foo;
class Inner {
public void bar() {
System.out.println(Outer.this.foo);
}
}
}
this(arg1, arg2); All other usages just a matter of style.
Aside from that case (which is quite common, tough I prefer to name the variable and the parameter differently so I can distinguish them better) and from using it as a constructor, there is another case.
Somethimes you want to pass the very instantiated object to a method. In that case you use this as a parameter for a method that recieves a class of that instance. For example, having a method with an auxiliar class that does increments:
public class MyClass {
private Integer value = 0; //Assume this has setters and getters
public void incrementValue() {
Incrementer.addOne(this);
}
}
And the incrementer class has a method like this one:
public static void addOne(MyClass classToIncrement) {
Integer currentValue = classToIncrement.getValue();
currentValue++;
classToIncrement.setValue(currentValue);
}
For more information, check the documentation.
The Fluent Interface pattern essentially means returning this from "setter" methods, allowing you to "chain up" method calls.
StringBuilder is one example from the JDK that has a fluent interface. Here's how it works:
int count = 5;
StringBuilder sb = new StringBuilder();
String result = sb.append("The total is ").append(count).append(".").toString();
The last line above is equivalent to:
sb.append("The total is ");
sb.append(count);
sb.append(".");
String result = sb.toString();
but results in less, and arguably more readable, code.
The implementations of the various append() methods all return this.
In most cases, when referring to methods or attributes from within a class, this is unnecessary. It however improves readability by making it clear that the variable is stored in the class scope instead of the function scope.
"Within an instance method or a constructor, this is a reference to the current object — the object whose method or constructor is being called. You can refer to any member of the current object from within an instance method or a constructor by using this."
I don't know who taught you in that way but to my knowledge, this is refrence to the current object.
returnType method(dataType val){
dataType myVariable = someOperation(this.val);
return myVariable;
}
docs.oracle.comsays detail about it.
