Palabra clave esto {en ejemplos}

En JavaRush, los estudiantes conocen la palabra clave literalmente desde las primeras conferencias this. Y con el tiempo queda claro lo que significa. Pero muchos, mirando hacia atrás, probablemente se dirán honestamente que durante mucho tiempo no pudieron darse cuenta del zen de esta palabra clave. En este artículo levantamos el velo de los secretos sobre el uso de palabras clave thispara aquellos que aún no pueden descifrarlo... ¡Bienvenido! Si elige el libro de referencia de Java de Schildt , en la página 171 leerá que thisse requiere una palabra clave para que un método pueda hacer referencia al objeto que lo llamó. En realidad, este podría ser el final. Pero necesitamos detalles. Como regla general, thisse debe utilizar en dos casos:

1. Cuando una variable de instancia de clase y una variable de método/constructor tienen el mismo nombre;
2. Cuando necesita llamar a un constructor de un tipo (por ejemplo, un constructor predeterminado o parametrizado) de otro. Esto también se denomina llamada explícita al constructor.

Eso es todo, en realidad no mucho, solo dos casos en los que se utiliza esta temida palabra clave. Ahora veamos estas dos situaciones con ejemplos.

Ejemplo uno: la variable de instancia y la variable de método tienen el mismo nombre

Digamos que tenemos una clase Humanpara la cual el campo "nombre" está definido: creemos nameun definidor para la variable (el definidor funciona bastante y no hay ningún truco aquí): tenga en cuenta que estamos pasando la variable al método (setter ) . Introdujimos una nueva variable y (en general) podríamos llamarla como quisiéramos porque solo sería visible dentro de las {llaves} del método . Observe que hay una línea en el configurador: setNameString newNamesetName

name = newName;

Es decir, de hecho, introdujimos una nueva variable newNamey la asignamos a una variable que ya existía en la clase name. A muchos programadores les pareció extraño introducir una variable con un nuevo nombre si al final hablamos de lo mismo. Sobre el nombre en la clase Human. Por lo tanto, los desarrolladores del lenguaje pensaron en hacer más conveniente el uso de un nombre de variable. En otras palabras, ¿por qué tener dos nombres para una variable que significa lo mismo? Es decir, me gustaría hacer algo como esto: Pero en este caso surge un problema . Ahora tenemos dos variables que tienen el mismo nombre. Uno String namepertenece a la clase Humany el otro String namea su método setName. Por lo tanto, la máquina Java no sabe a qué variable te refieres cuando escribes una cadena en un definidor:

name = name;

Java toma el más cercano, namedel método setName: y resulta que simplemente le asignas un valor a una variable namede este método. Lo cual por supuesto no tiene ningún sentido. Por lo tanto, se necesitaba alguna forma de distinguir una variable namede una clase Humande una variable namede un método setName. Para solucionar este problema se introdujo la palabra clave this, que en este caso indicará que es necesario llamar a una variable no de un método, sino de una clase Human: Es decir, thisse referirá al objeto llamante, como se dijo al principio del artículo. Como resultado, el nombre de la persona setNamese establecerá a través del configurador en el objeto creado. A continuación se muestra el código sin utilizar la palabra clave this. El código crea un objeto de clase Humany le da un nombre: Y a continuación se muestra el código del programa con la palabra clave this:

public class Solution{
    public static void main(String[] args) {
        Human human1 = new Human();
        human1.setName("Volodya");
        human1.print();
    }
}
class Human{
    String name;
    public String getName() {
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    void print(){
        System.out.println(name);
    }
}

Por lo tanto, thisevita introducir nuevas variables para denotar lo mismo, lo que hace que el código esté menos "sobrecargado" con variables adicionales.

Ejemplo dos: usar esto para llamar explícitamente a un constructor

Llamar a un constructor desde otro puede ser útil cuando (por extraño que parezca) tiene varios constructores y no desea reescribir el código de inicialización proporcionado anteriormente en el constructor en un nuevo constructor. ¿Confundido? No todo es tan aterrador como parece. Mire el código a continuación, tiene dos constructores de clases Human:

class Human{
    int age;
    int weight;
    int height;

    Human(int age, int weight){
        this.age = age;
        this.weight = weight;
    }
    Human(int age, int weight, int height){
        //llamas al constructor con dos parámetros
        this(age, weight);
        //y agrega la variable que falta
        this.height = height;
    }
}

Aquí primero tenemos un constructor de dos parámetros que acepta int agey int weight. Digamos que escribimos dos líneas de código en él:

this.age = age;
this.weight = weight;

y luego decidieron agregar otro constructor, con tres parámetros, que además de la edad y el peso, también toma la altura. En el nuevo constructor podrías escribir esto:

this.age = age;
this.weight = weight;
this.height = height;

Pero en lugar de repetir el código que ya has escrito en este constructor, puedes usar una palabra clave para thisllamar explícitamente al constructor con dos parámetros:

this(age, weight);
// y agrega la variable que falta:
this.height = height;

Entonces le estás diciendo al constructor con tres parámetros:

• Llame a este constructor, que tiene dos parámetros.
• y agregue la variable que falta.

Eso es todo =). Finalmente, observamos que la palabra clave this en Java se usa solo como parte de métodos o constructores de una instancia de clase. Pero implícitamente, la palabra clave thisse pasa a todos los métodos excepto a los estáticos (de ahí que thisa menudo se la llame parámetro implícito) y se puede usar para hacer referencia al objeto que llamó al método. No hay por qué tener miedo de esta palabra clave, porque Thisno da miedo.