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 utiliza para hacer referencia 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 :
esta referencia = Main @ 23fc625e referencia de objeto = Main @ 23fc625e
En el ejemplo anterior, creamos un objeto llamado obj de la clase Main. Luego imprimimos la referencia al objeto obj y la thispalabra clave de la clase.
Aquí, podemos ver que la referencia de obj y thises la misma. Significa que esto no es más que la referencia al objeto actual.
Uso de esta palabra clave
Hay varias situaciones en las que thisse utiliza comúnmente la palabra clave.
Usar esto para nombres de variables de ambigüedad
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 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 la thispalabra 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 :
mc.age = 0
En el ejemplo anterior, hemos pasado 8como valor al constructor. Sin embargo, lo estamos obteniendo 0como 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 la thispalabra 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, thisdentro del constructor se reemplaza por el objeto obj que ha llamado al constructor. Por tanto, a la variable edad se le asigna el valor 8.
Además, si el nombre del parámetro y la variable de instancia es diferente, 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 la thispalabra clave es en los 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 utilizado la thispalabra clave:
- para asignar valor dentro del método setter
- para acceder al valor dentro del método getter
Usando esto en Constructor Overloading
Mientras trabajamos con la sobrecarga de constructores, es posible que tengamos que invocar un constructor de otro constructor. En tal caso, no podemos llamar al constructor explícitamente. En cambio, tenemos que usar thispalabras 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 utilizado la thispalabra clave,
- llamar al constructor
Complex(int i, int j)desde el constructorComplex(int i) - llamar al constructor
Complex(int i)desde el constructorComplex()
Note la línea,
System.out.println(c1);
Here, when we print the object c1, the object is converted into a string. In this process, the toString() is called. Since we override the toString() method inside our class, we get the output according to that method.
One of the huge advantages of this() is to reduce the amount of duplicate code. However, we should be always careful while using this().
This is because calling constructor from another constructor adds overhead and it is a slow process. Another huge advantage of using this() is to reduce the amount of duplicate code.
Note: Invoking one constructor from another constructor is called explicit constructor invocation.
Passing this as an Argument
We can use this keyword to pass the current object as an argument to a method. For example,
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 :
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
En el ejemplo anterior, dentro del constructor ThisExample(), observe la línea,
add(this);
Aquí, llamamos al add()método pasando esto como argumento. Dado que esta palabra clave contiene la referencia al objeto obj de la clase, podemos cambiar el valor de xey dentro del add()método.
