The this Keyword · A Palavra-chave this
A parameter can hide the field it should update
- An object has name "Ada". setName(String name) runs name = name; with the argument "Bo".
- Both unqualified names refer to the parameter, so the object still has "Ada". this.name = name assigns the parameter value to the field instead.
"This object"
- Inside an instance method,
thisrefers to the object the method was called on.student.addScore(10)runs withthis= thatstudent. this.scoremeans "thescoreof the object I'm working on." It lets a method talk about its own object explicitly.
Distinguishing field from parameter
- The main use: tell an instance variable apart from a parameter of the same name.
void setName(String name) { this.name = name; } this.nameis the instance variable; plainnameis the parameter. This is the standard fix for the shadowing bug from 3.8.
Access to the receiver object
thisgives a method a handle on the exact object it was called on. Every instance method has an implicitthis, whether you write it or not.- When score names an unshadowed instance field,
score += s;uses · usa this.score. If a parameter or local named score shadows it, the unqualified name instead refers to that variable. You writethisexplicitly only when needed (like resolving shadowing).
this refers to the receiver object · this refere-se ao objeto que chamou
Inside setName, this is the ada object it was called on.
Inside an instance method, this refers to...
this is a handle on the current object.
In setName(String name) { this.name = name; }, this.name is...
this.name is the field; plain name is the parameter.
The this keyword can be used inside a static method.
Static methods have no particular object, so no this.
Writing name = name; (no this) inside setName(String name) does what?
Both names are the parameter; use this.name to reach the field.
Every instance method has an implicit this, whether you write it or not.
An instance method has a current receiver. An unqualified score names this.score only if no parameter or local shadows that field.
No this in a static method
- A static method has no · nenhuma
this— it isn't tied to any particular object. So a static method cannot usethisor an unqualified instance field, but may read an instance field through an explicit reference when access permission allows it. - Trying to use
thisin a static method is a compile error. If you needthis, the method must be an instance method, not static.
Use this.field = param; to defeat shadowing — this.name is the instance variable, plain name is the parameter. Writing name = name; (no this) just assigns the parameter to itself. And this doesn't exist in a static method — a static method has no particular object, so using this there won't compile.
Type the field value after the faulty setName("Bo") call on the described object.
The parameter assigns to itself; the field is unchanged until this.name is used on the left.
If alias and a reference the same Student, alias.setName("Di") changes the name later read through a.
Both references identify the same receiver object, whose field is updated.
Code in object b calls a.setName("Cy"). Inside setName, which object is this?
The receiver a supplies this, regardless of which other object's code initiated the call.
Fixing the shadowing bug with this:
- Instance variable
private String name; void setName(String name) { this.name = name; }— correct!this.name(the field) gets the value ofname(the parameter).
Carry the reasoning to a new case
- Trace a and b as separately created students named Ada and Bo.
a.setName("Cy")changes a to Cy while b stays Bo. If alias=a,alias.setName("Di")changes that same first object, so a now reads Di. - The receiver is the object the instance method acts on, not necessarily the object whose code called it. A static method can operate on an explicit object reference, but has no implicit this.
this refers to the current object — the one an instance method was called on. Its key use is resolving shadowing: this.name = name; assigns the parameter to the instance variable. Every instance method has an implicit this, but a static method has none, so this can't be used there.