Palabra clave this de Java

En este artículo, entenderemos a través de ejemplos la palabra clave this en Java, cómo y dónde se utilizan.

Palabra clave this

En Java, la palabra clave this se usa para referirse al objeto actual en un método o constructor. Por ejemplo,

class Main {
　　　　int instVar;
　　　　Main(int instVar){
　　　　　　　　this.instVar = instVar;
　　　　　　　　System.out.println("Referencia this= ",　+　this);
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　Main obj = new Main(8);
　　　　　　　　System.out.println("Referencia de objeto= ",　+　obj);
　　　　}
}

Salida:

Referencia this = com.ThisAndThat.MyClass@74a14482
Referencia de objeto = com.ThisAndThat.MyClass@74a14482

En el ejemplo anterior, creamos un objeto llamado obj de la clase Main. Luego, imprimimos la referencia al objeto de la clase y a la palabra clave this.

Aquí, podemos ver que la referencia de obj y this son las mismas. Esto significa que esto es solo una referencia al objeto actual.

Uso de la palabra clave this

En varios casos, se usa comúnmente la palabra clave this.

Uso del método this para manejar la ambigüedad de los nombres de variables

En Java, no se permite declarar dos o más variables con el mismo nombre en un ámbito (de clase o método). Sin embargo, las variables de instancia y los parámetros pueden tener el mismo nombre. Por ejemplo,

class MyClass {
　　　　//　Variables de instancia
　　　　int age;
　　　　//　Parámetros
　　　　MyClass(int age){
　　　　　　　　age = age;
　　　　}
}

En el programa anterior, las variables de instancia y los parámetros tienen el mismo nombre: age. Aquí, debido a la falta de claridad en los nombres, el compilador de Java se siente confundido.

En este caso, usamos la palabra clave this. Por ejemplo,

Primero, veamos un ejemplo sin usar la palabra clave this:

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:

mc.age = 0

En el ejemplo anterior, hemos pasado un valor8Se pasó al constructor. Pero, el 0 que obtenemos es la salida. Esto se debe a que el compilador de Java se siente confundido debido a la falta de claridad en los nombres de las variables de instancia y los parámetros.

现在，让我们使用this关键字重写上面的代码。

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

现在，我们得到了预期的输出。这是因为当构造函数被调用时，构造函数内部的内容被调用构造函数的对象obj所替换。因此，age变量被赋值为8。

另外，如果参数和实例变量的名称不同，则编译器会自动附加this关键字。例如代码：

class Main {
　　　　int age;
　　　　Main(int i) {
　　　　　　　　age = i;
　　　　}
}

等同于：

class Main {
　　　　int age;
　　　　Main(int i) {
　　　　　　　　this.age = i;
　　　　}
}

this 与Getters和Setters

this关键字的另一个常见用法是在类的setter和getter方法中。例如：

class Main {
　　　String name;
　　　//　setter 方法
　　　void setName( String name ) {
　　　　　　　this.name = name;
　　　}
　　　//　getter 方法
　　　String getName(){
　　　　　　　return this.name;
　　　}
　　　public static void main(String[] args) {
　　　　　　　Main obj = new Main();
　　　　　　　//　调用setter和getter方法
　　　　　　　obj.setName("Seagull");
　　　　　　　System.out.println("obj.name: ",+obj.getName());
　　　}
}

Salida:

obj.name: Seagull

在这里，我们使用了this关键字：

• 在setter方法中分配值

• 在getter方法中访问值

在构造函数重载中使用this

在处理构造函数重载时，我们可能必须从另一个构造函数调用一个构造函数。在这种情况下，我们不能显式调用构造函数。相反，我们必须使用this关键字。

在这里，我们使用this关键字的另一种形式。也就是this()。让我们举一个例子

class Complex {
　　　　private int a, b;
　　　　//具有两个参数的构造函数
　　　　private Complex( int i, int j ){
　　　　　　　　this.a = i;
　　　　　　　　this.b = j;
　　　　}
　　　　//Constructor con un solo parámetro
　　　　private Complex(int i){
　　　　　　　　//Llamar al constructor con dos parámetros
　　　　　　　　this(i, i);　
　　　　}
　　　　//Constructor sin parámetros
　　　　private Complex(){
　　　　　　　　//Llamar al constructor con un solo parámetro
　　　　　　　　this(0);
　　　　}
　　　　@Override
　　　　public String toString(){
　　　　　　　　return this.a　+　"　+　"　+　this.b　+　"i";
　　　　}
　　　　public static void main(String[] args) {
　　
　　　　　　　　　　　　　　　　//Crear un objeto de la clase Complex
　　　　　　　　　　　　　　　　//Usar2parámetros para llamar al constructor　
　　　　　　　　Complex c1　= new Complex(2,　3);　
　　　　
　　　　　　　　//Llamar al constructor con un solo parámetro
　　　　　　　　Complex c2　= new Complex(3);
　　　　　　　　//Llamar al constructor sin parámetros
　　　　　　　　Complex c3　= new Complex();
　　　　　　　　//Imprimir el objeto
　　　　　　　　System.out.println(c1);
　　　　　　　　System.out.println(c2);
　　　　　　　　System.out.println(c3);
　　　　}
}

Salida:

2　+　3i
3　+　3i
0　+　0i

En el ejemplo anterior, hemos utilizado la palabra clave this,

• Llamar al constructor Complex(inti) desde el constructor Complex(inti, intj)

• Llamar al constructor Complex() desde el constructor Complex(int i)

Nota esta línea,

System.out.println(c1);

Aquí, cuando imprimimos el objeto c1Cuando, el objeto se convierte en una cadena. En este proceso, se llama a toString(). Debido a que hemos sobrescrito el método toString() en la clase, obtenemos la salida según ese método.

　Una de las mayores ventajas de this() es reducir la cantidad de código repetido. Pero, al usar this(), debemos ser especialmente cuidadosos.

　Esto es porque llamar a un constructor desde otro constructor aumenta el costo y es un proceso lento. Otra gran ventaja de usar this() es reducir la cantidad de código repetido.

Nota：Llamar a un constructor desde otro constructor se llama llamada de constructor explícito.

this como parámetro

Podemos usar la palabra clave this para pasar el objeto actual como parámetro a un método. Por ejemplo,

class ThisExample {
　　　　//　declarar variables
　　　　int x;
　　　　int y;
　　　　ThisExample(int x, int y) {
　　　　　　　　　　//Asignar valores a las variables dentro del constructor
　　　　　　　　this.x = x;
　　　　　　　　this.y = y;
　　　　　　　　//Valores de x y antes de llamar a add()
　　　　　　　　System.out.println("Antes de pasar this a la método addTwo():;")
　　　　　　　　System.out.println("x = ")}　+　this.x　+　", y = ",　+　this.y);
　　　　　　　　//Llamar al método add() y pasar this como parámetro
　　　　　　　　add(this);
　　　　　　　　//Valores de x y después de llamar a add()
　　　　　　　　System.out.println("Después de pasar this a la método addTwo():;")
　　　　　　　　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:

Antes de pasar this a la función addTwo():
x =　1, y =　-2
Después de pasar this a la función addTwo():
x =　3, y = 0

En el ejemplo anterior, en el constructor ThisExample(), presta atención a la siguiente línea:

add(this);

Aquí, llamamos al método add() pasando this como parámetro. Porque el keyword this contiene una referencia al objeto de la clase obj, podemos cambiar los valores de x y y en el método add().