En este artículo, aprenderá acerca de esta palabra clave en Java; cómo y dónde se usan con la ayuda de ejemplos.
esta palabra clave
En Java, se
this
refiere al objeto actual dentro de métodos o constructores. Tomemos un ejemplo para demostrarlo.
class MyClass {
int instVar;
MyClass(int instVar){
this.instVar = instVar;
System.out.println("this reference = " + this);
}
public static void main(String[] args) {
MyClass obj = new MyClass(8);
System.out.println("object reference = " + obj);
}
}
Cuando ejecutas el programa, la salida será:
esta referencia = com.ThisAndThat.MyClass@74a14482 referencia de objeto = com.ThisAndThat.MyClass@74a14482
Observe que el id del objeto de obj y
this
es el mismo. Es decir, this
no es más que la referencia al objeto actual.
Hay 3 situaciones en las que esta palabra clave se usa comúnmente.
1. Usando esto para desambigar referencias variables
En Java, no está permitido declarar dos o más variables que tengan el mismo nombre dentro de un ámbito (ámbito de clase o ámbito de método). Sin embargo, las variables y parámetros de instancia pueden tener el mismo nombre. Me gusta esto:
clase MyClass { int instVar; // variable de instancia instVar MyClass (int instVar) {// parámetro instVar instVar = instVar; } }
En el programa anterior, el compilador de Java está confundido debido a la ambigüedad del nombre. Por lo tanto, para abordar este problema,
this
se utiliza la palabra clave.
Primero, veamos un ejemplo sin usar la
this
palabra clave:
class MyClass {
int instVar;
MyClass(int instVar){
instVar = instVar;
}
public static void main(String[] args) {
MyClass mc = new MyClass(8);
System.out.println("mc.instVar = " + mc.instVar);
}
}
Cuando ejecutas el programa, la salida será:
mc.instVar = 0
Es posible que haya esperado 8 como salida, pero, en cambio, obtiene 0. Esto se debe a que el compilador de Java se confunde debido a la ambigüedad en los nombres entre la variable de instancia y el parámetro constructor.
Ahora, reescribamos el código anterior y usemos la
this
palabra clave para resolver este problema.
class MyClass{
int instVar;
MyClass(int instVar){
this.instVar = instVar;
}
public static void main(String[] args) {
MyClass obj = new MyClass(8);
System.out.println("obj.instVar = " + obj.instVar);
}
}
Cuando ejecutas el programa, la salida será:
mc.instVar = 8
Ahora, obtendrá el resultado esperado. Es porque cuando está creando un objeto, el compilador de Java sabe qué objeto ha invocado al constructor.
Cuando el compilador de Java invoca al constructor,
this
dentro del constructor se reemplaza por el objeto que llamó al constructor.
Nota: Si pasa un parámetro que tiene un nombre diferente al de las variables de instancia, el compilador agrega automáticamente esta palabra clave.
Este código
clase MyClass { int instVar; MyClass (int i) { instVar = i; } }
es equivalente a:
clase MyClass { int instVar; MyClass (int i) { this.instVar = i; } }
Otro uso común de la
this
palabra clave es en los métodos setters y getters de una clase. Por ejemplo:
class POJO {
String name;
void setName( String name ) {
this.name = name;
}
String getName(){
return this.name;
}
public static void main( String[] args ) {
POJO pojo = new POJO();
pojo.setName("Toshiba");
System.out.println("pojo.name: "+pojo.getName());
}
}
Cuando ejecutas el programa, la salida será:
pojo.name: Toshiba
2. Usando esto en la sobrecarga del constructor
Mientras trabaja con la sobrecarga del constructor , puede resultarle útil invocar un constructor de otro constructor. Pero, los constructores no pueden ser llamados explícitamente. Por lo tanto, para lograr esto, puede usar otra forma de
this
palabra clave this()
.
El pseudocódigo se muestra aquí:
esto (arg-list)
Así es como puedes llamar a un constructor desde otro constructor usando
this
.
class Complex {
private int a, b;
// parameterize constructor
private Complex( int i, int j ){
this.a = i;
this.b = j;
}
private Complex(int i){
this(i, i); // invokes Complex(int i, int j);
}
private Complex(){
this(0); // invokes Complex(int i);
}
@Override
public String toString(){
return this.a + " + " + this.b + "i";
}
public static void main( String[] args ) {
Complex c1 = new Complex(2, 3);
Complex c2 = new Complex(3);
Complex c3 = new Complex();
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
}
}
Cuando ejecutas el programa, la salida será:
2 + 3i 3 + 3i 0 + 0i
En el programa anterior, no importa qué constructor se llame durante la instanciación del objeto, el constructor parametrizado se llamará eventualmente.
Debes tener cuidado al usar
this()
. Los constructores que llaman se this()
ejecutan lentamente porque llamar a otro constructor sobrecargado agrega sobrecarga. Si su clase se usa para crear solo un puñado de objetos, entonces usar this()
es fructífero. Otra gran ventaja de usar this()
es reducir la cantidad de código duplicado.
Por cierto, invocar un constructor de otro constructor se llama invocación explícita del constructor.
3. Pasando esto como un argumento
Si necesita pasar el objeto actual como argumento a un método, puede usarlo
this
.
class ThisExample {
int x;
int y;
ThisExample(int x, int y) {
this.x = x;
this.y = y;
System.out.println("Before passing this to addTwo() method:");
System.out.println("x = " + this.x + ", y = " + this.y);
addTwo(this);
System.out.println("After passing this to addTwo() method:");
System.out.println("x = " + this.x + ", y = " + this.y);
}
void addTwo(ThisExample o){
o.x += 2;
o.y += 2;
}
}
class Demo {
public static void main( String[] args ) {
ThisExample obj = new ThisExample(1, -2);
}
}
Cuando ejecutas el programa, la salida será:
Antes de pasar esto al método addTwo (): x = 1, y = -2 Después de pasar esto al método addTwo (): x = 3, y = 0
Aquí, el
addTwo()
método se llama con this
un argumento desde el interior del constructor.
0 Comentarios
Dejanos tu comentario para seguir mejorando!