Java esta palabra clave

En CodeGym, a los estudiantes se les presenta Java con esta palabra clave literalmente desde las primeras lecciones. Con el tiempo, su significado se aclara. Pero mirando hacia atrás, muchas personas probablemente admiten que durante mucho tiempo no pudieron entender el Zen de esta palabra clave. Este artículo abrirá el telón que cubre los secretos de esta palabra clave para cualquiera que aún no haya podido hacerlo... Tengo la referencia de Java de Schildt , luego en la página 171 puede ver que la palabra clave this es necesario para que un método haga referencia al objeto que lo llamó. Podríamos terminar la lección con eso. Pero necesitamos detalles. Como regla general, debe usar esto en dos casos:

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

Y eso es todo: solo hay dos casos en los que se usa esta temible palabra clave. Ahora veamos estos dos casos en ejemplos.

Ejemplo 1: una variable de instancia y una variable de método tienen el mismo nombre.

Supongamos que tenemos una clase humana que define un campo de nombre: creemos un setter para la variable de nombre (el setter es completamente funcional, no hay problema aquí):

class Human {
    String name;


    public void setName(String newName) {
        name = newName;
    }
}

Tenga en cuenta que pasamos String newName al método setter setName . Declaramos una nueva variable y podríamos haberla nombrado como quisiéramos porque solo será visible dentro de las llaves ({}) que encierran el método setName . Tenga en cuenta que el setter tiene una sola línea:

name = newName;

Aquí hemos introducido una nueva variable llamada newName y la hemos asignado a la variable de nombre existente del objeto . Muchos programadores pueden encontrar extraño introducir una variable con un nuevo nombre cuando en última instancia estamos hablando de lo mismo. Es decir, estamos hablando del campo de nombre en la clase Human . Es por eso que los creadores de Java idearon una forma de usar convenientemente el mismo nombre de variable. En otras palabras, ¿por qué tener dos nombres para una variable que denota lo mismo? En otras palabras, queremos hacer algo como esto:

class Human {
    String name;


    public void setName(String name) {
        name = name;
    }
}

Pero aquí nos encontramos con un problema . Ahora tenemos dos variables con el mismo nombre. Un nombre String pertenece a la clase Human , mientras que el otro nombre String pertenece a su método setName . Como resultado, la JVM no sabría a qué variable te refieres cuando escribes la siguiente línea en el setter:

name = name;

Java asume que te refieres a la variable de nombre más cercana , es decir, la del método setName : así que resulta que simplemente estás asignando la variable de nombre del método a sí misma. Lo cual, por supuesto, no tiene ningún sentido. Por lo tanto, el lenguaje necesitaba alguna forma de distinguir la variable de nombre de la clase Humana de la variable de nombre en el método setName . Este problema se resolvió introduciendo la palabra clave this , que en este caso indica que pretende hacer referencia a la variable asociada con una instancia de la clase Human , no a la variable en el método: En otras palabras, estose refiere al objeto que llama, como mencionamos al principio del artículo. Como resultado, el método setName establece el nombre de la persona en el objeto creado. A continuación se muestra el código del programa sin usar la palabra clave this . El código crea un objeto humano y le asigna un nombre: Y aquí está el código con la palabra clave this :

public class Solution {
    public static void main(String[] args) {
        Human human1 = new Human();
        human1.setName("Vinny");
        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, esto nos permite evitar la introducción de nuevas variables para indicar lo mismo, lo que hace que el código sea más limpio y esté menos abarrotado de variables adicionales.

Ejemplo 2: usar esto para una llamada de constructor explícita

Llamar a un constructor desde otro puede ser útil cuando tiene (por extraño que parezca) varios constructores y no desea que el nuevo constructor duplique el código de inicialización previamente escrito en un constructor diferente. ¿Confundido? No es tan aterrador como parece. Mira el código de abajo. Tiene dos constructores para la clase 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) {
        // Call the constructor with two parameters
        this(age, weight);
        // and then initialize the missing variable
        this.height = height;
    }
}

Aquí primero proporcionamos un constructor con dos parámetros: int age y int weight . Supongamos que tiene dos líneas de código:

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

Posteriormente decidimos agregar otro constructor con tres parámetros, agregando altura a los parámetros de edad y peso existentes. Podrías escribir el nuevo constructor así:

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

Pero en lugar de repetir el código existente en este constructor, puede usar esta palabra clave para llamar explícitamente al constructor con dos parámetros:

this(age, weight);
// and then initialize the missing variable:
this.height = height;

Es como si le estuviéramos diciendo al constructor de tres parámetros:

• llama a este otro constructor que tiene dos parámetros
• y luego agregar otra variable.

Eso es todo =). Finalmente, notamos que en Java la palabra clave this se usa solo en métodos y constructores. Pero esto se pasa implícitamente a todos los métodos no estáticos (es por eso que a menudo se le llama parámetro implícito) y se puede usar para referirse al objeto que llamó al método. No tengas miedo de esta palabra clave, porque no da miedo.