Java keywords

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 thisrefiere 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 thises el mismo. Es decir, thisno 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, thisse utiliza la palabra clave.

Primero, veamos un ejemplo sin usar la thispalabra 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  thispalabra 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, thisdentro 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 thispalabra 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 thispalabra 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 thisun argumento desde el interior del constructor.