Java esta palabra clave
Java esta palabra clave
En este artículo, aprenderemos sobre esta palabra clave en Java, cómo y dónde usarla con la ayuda de ejemplos.
esta palabra clave
En Java, esta palabra clave se usa para referirse al objeto actual dentro de un método o un constructor. Por ejemplo,
class Main {
int instVar;
Main(int instVar){
this.instVar = instVar;
System.out.println("this reference = " + this);
}
public static void main(String[] args) {
Main obj = new Main(8);
System.out.println("object reference = " + obj);
}
} Salida :
this reference = Main@23fc625e object reference = Main@23fc625e
En el ejemplo anterior, creamos un objeto llamado obj de la clase Principal . Luego imprimimos la referencia al objeto obj y this palabra clave de la clase.
Aquí, podemos ver que la referencia de ambos obj y this es el mismo. Significa que esto no es más que la referencia al objeto actual.
Uso de esta palabra clave
Hay varias situaciones en las que this la palabra clave se usa comúnmente.
Uso de esto para nombres de variables de ambigüedad
En Java, no está permitido declarar dos o más variables con el mismo nombre dentro de un alcance (alcance de clase o alcance de método). Sin embargo, las variables de instancia y los parámetros pueden tener el mismo nombre. Por ejemplo,
class MyClass {
// instance variable
int age;
// parameter
MyClass(int age){
age = age;
}
} En el programa anterior, la variable de instancia y el parámetro tienen el mismo nombre:edad. Aquí, el compilador de Java se confunde debido a la ambigüedad del nombre.
En tal situación, usamos esta palabra clave. Por ejemplo,
Primero, veamos un ejemplo sin usar this palabra clave:
class Main {
int age;
Main(int age){
age = age;
}
public static void main(String[] args) {
Main obj = new Main(8);
System.out.println("obj.age = " + obj.age);
}
} Salida :
obj.age = 0
En el ejemplo anterior, hemos pasado 8 como un valor para el constructor. Sin embargo, estamos obteniendo 0 como salida. Esto se debe a que el compilador de Java se confunde debido a la ambigüedad en los nombres entre la instancia, la variable y el parámetro.
Ahora, reescribamos el código anterior usando this palabra clave.
class Main {
int age;
Main(int age){
this.age = age;
}
public static void main(String[] args) {
Main obj = new Main(8);
System.out.println("obj.age = " + obj.age);
}
} Salida :
obj.age = 8
Ahora, estamos obteniendo el resultado esperado. Es porque cuando se llama al constructor, this dentro del constructor se reemplaza por el objeto obj que ha llamado al constructor. De ahí la edad a la variable se le asigna el valor 8 .
Además, si el nombre del parámetro y la variable de instancia son diferentes, el compilador agrega automáticamente esta palabra clave. Por ejemplo, el código:
class Main {
int age;
Main(int i) {
age = i;
}
} es equivalente a:
class Main {
int age;
Main(int i) {
this.age = i;
}
} esto con Getters y Setters
Otro uso común de this la palabra clave está en métodos setters y getters de una clase Por ejemplo:
class Main {
String name;
// setter method
void setName( String name ) {
this.name = name;
}
// getter method
String getName(){
return this.name;
}
public static void main( String[] args ) {
Main obj = new Main();
// calling the setter and the getter method
obj.setName("Toshiba");
System.out.println("obj.name: "+obj.getName());
}
} Salida :
obj.name: Toshiba
Aquí, hemos usado this palabra clave:
- para asignar valor dentro del método setter
- para acceder al valor dentro del método getter
Uso de esto en la sobrecarga de constructores
Mientras trabajamos con la sobrecarga de constructores, es posible que tengamos que invocar un constructor desde otro constructor. En tal caso, no podemos llamar al constructor explícitamente. En su lugar, tenemos que usar this palabra clave.
Aquí, usamos una forma diferente de esta palabra clave. Es decir, this() . Tomemos un ejemplo,
class Complex {
private int a, b;
// constructor with 2 parameters
private Complex( int i, int j ){
this.a = i;
this.b = j;
}
// constructor with single parameter
private Complex(int i){
// invokes the constructor with 2 parameters
this(i, i);
}
// constructor with no parameter
private Complex(){
// invokes the constructor with single parameter
this(0);
}
@Override
public String toString(){
return this.a + " + " + this.b + "i";
}
public static void main( String[] args ) {
// creating object of Complex class
// calls the constructor with 2 parameters
Complex c1 = new Complex(2, 3);
// calls the constructor with a single parameter
Complex c2 = new Complex(3);
// calls the constructor with no parameters
Complex c3 = new Complex();
// print objects
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
}
} Salida :
2 + 3i 3 + 3i 0 + 0i
En el ejemplo anterior, hemos usado this palabra clave,
- para llamar al constructor
Complex(int i, int j)del constructorComplex(int i) - para llamar al constructor
Complex(int i)del constructorComplex()
Fíjate en la línea,
System.out.println(c1);
Aquí, cuando imprimimos el objeto c1 , el objeto se convierte en una cadena. En este proceso, el toString() se llama. Dado que anulamos el toString() dentro de nuestra clase, obtenemos el resultado de acuerdo con ese método.
Una de las grandes ventajas de this() es reducir la cantidad de código duplicado. Sin embargo, siempre debemos tener cuidado al usar this() .
Esto se debe a que llamar al constructor desde otro constructor agrega una sobrecarga y es un proceso lento. Otra gran ventaja de usar this() es reducir la cantidad de código duplicado.
Nota :La invocación de un constructor desde otro constructor se denomina invocación explícita del constructor.
Pasar esto como un argumento
Podemos usar this palabra clave para pasar el objeto actual como argumento a un método. Por ejemplo,
class ThisExample {
// declare variables
int x;
int y;
ThisExample(int x, int y) {
// assign values of variables inside constructor
this.x = x;
this.y = y;
// value of x and y before calling add()
System.out.println("Before passing this to addTwo() method:");
System.out.println("x = " + this.x + ", y = " + this.y);
// call the add() method passing this as argument
add(this);
// value of x and y after calling add()
System.out.println("After passing this to addTwo() method:");
System.out.println("x = " + this.x + ", y = " + this.y);
}
void add(ThisExample o){
o.x += 2;
o.y += 2;
}
}
class Main {
public static void main( String[] args ) {
ThisExample obj = new ThisExample(1, -2);
}
} Salida :
Before passing this to addTwo() method: x = 1, y = -2 After passing this to addTwo() method: x = 3, y = 0
En el ejemplo anterior, dentro del constructor ThisExample() , observe la línea,
add(this);
Aquí, estamos llamando al add() método pasando esto como un argumento. Dado que esta palabra clave contiene la referencia al objeto obj de la clase, podemos cambiar el valor de x y y dentro del add() método.
Java