¿Cuál es el significado de “esto” en Java?

Normalmente, uso this solo en constructores.

Entiendo que se usa para identificar la variable de parámetro (mediante el uso de this.something ), si tiene el mismo nombre con una variable global.

Sin embargo, no sé cuál es el verdadero significado de this en Java y qué sucederá si utilizo this sin punto ( . ).

this refiere al objeto actual.

Cada método no estático se ejecuta en el contexto de un objeto. Entonces, si tienes una clase como esta:

 public class MyThisTest { private int a; public MyThisTest() { this(42); // calls the other constructor } public MyThisTest(int a) { this.a = a; // assigns the value of the parameter a to the field of the same name } public void frobnicate() { int a = 1; System.out.println(a); // refers to the local variable a System.out.println(this.a); // refers to the field a System.out.println(this); // refers to this entire object } public String toString() { return "MyThisTest a=" + a; // refers to the field a } } 

Luego se frobnicate() en new MyThisTest()

 1
 42
 MyThisTest a = 42

Entonces efectivamente lo usa para múltiples cosas:

  • aclara que estás hablando de un campo, cuando también hay algo más con el mismo nombre que un campo
  • referirse al objeto actual como un todo
  • invocar otros constructores de la clase actual en su constructor

Lo siguiente es copiar y pegar desde aquí , pero explica muy bien todos los diferentes usos de this palabra clave:

Definición: this palabra clave de Java se usa para referir la instancia actual del método en el que se usa.

Las siguientes son las formas de usar esto:

  1. Para indicar específicamente que se utiliza la variable de instancia en lugar de la variable estática o local. Es decir,

     private String javaFAQ; void methodName(String javaFAQ) { this.javaFAQ = javaFAQ; } 

    Aquí esto se refiere a la variable de instancia. Aquí la prioridad es alta para la variable local. Por lo tanto, la ausencia de this denota la variable local. Si la variable local que es el nombre del parámetro no es la misma que la variable de instancia, independientemente de si se usa o no, denota la variable de instancia.

  2. This se usa para referirse a los constructores

      public JavaQuestions(String javapapers) { this(javapapers, true); } 

    Esto invoca el constructor de la misma clase Java que tiene dos parámetros.

  3. This se usa para pasar la instancia java actual como parámetro

     obj.itIsMe(this); 
  4. Similar a lo anterior, esto también se puede usar para devolver la instancia actual

     CurrentClassName startMethod() { return this; } 

    Nota: Esto puede conducir a resultados no deseados mientras se usa en clases internas en los dos puntos anteriores. Dado que esto se referirá a la clase interna y no a la instancia externa.

  5. This se puede usar para obtener el control de la clase actual

     Class className = this.getClass(); // this methodology is preferable in java 

    Aunque esto puede hacerse por

     Class className = ABC.class; // here ABC refers to the class name and you need to know that! 

Como siempre, this está asociado con su instancia y esto no funcionará en métodos estáticos.

Para ser completo, this también se puede usar para referirse al objeto externo

 class Outer { class Inner { void foo() { Outer o = Outer.this; } } } 

Se refiere a la instancia actual de un objeto particular, por lo que podrías escribir algo como

 public Object getMe() { return this; } 

Un caso de uso común de this es para evitar el sombreado. Toma el siguiente ejemplo:

 public class Person { private final String name; public Person(String name) { // how would we initialize the field using parameter? // we can't do: name = name; } } 

En el ejemplo anterior, queremos asignar el miembro de campo usando el valor del parámetro. Dado que comparten el mismo nombre, necesitamos una forma de distinguir entre el campo y el parámetro. this nos permite acceder a los miembros de esta instancia, incluido el campo.

 public class Person { private final String name; public Person(String name) { this.name = name; } } 

En Swing es bastante común escribir una clase que implemente ActionListener y agregue la instancia actual (es decir, ‘esto’) como un ActionListener para componentes.

 public class MyDialog extends JDialog implements ActionListener { public MyDialog() { JButton myButton = new JButton("Hello"); myButton.addActionListener(this); } public void actionPerformed(ActionEvent evt) { System.out.println("Hurdy Gurdy!"); } } 

Si llama a myObject.method() , this se referirá a myObject inside method .

Se refiere a la instancia en la que se llama el método

 class A { public boolean is(Object o) { return o == this; } } A someA = new A(); A anotherA = new A(); someA.is(someA); // returns true someA.is(anotherA); // returns false 

Es “una referencia al objeto en el contexto actual” de manera efectiva. Por ejemplo, para imprimir “este objeto”, puede escribir:

 System.out.println(this); 

Tenga en cuenta que su uso de “variable global” está algo apagado … si usa this.variableName entonces, por definición, no es una variable global; es una variable específica de esta instancia en particular.

Los objetos tienen métodos y atributos (variables) que se derivan de las clases, con el fin de especificar qué métodos y variables pertenecen a un objeto particular, se usa this palabra reservada. en el caso de las variables de instancia, es importante entender la diferencia entre los parámetros implícitos y explícitos. Eche un vistazo a la llamada fillTank para el objeto audi .

 Car audi= new Car(); audi.fillTank(5); // 5 is the explicit parameter and the car object is the implicit parameter 

El valor en el paréntesis es el parámetro implícito y el objeto en sí es el parámetro explícito, los métodos que no tienen parámetros explícitos, usan parámetros implícitos, el método fillTank tiene un parámetro explícito y otro implícito.

Echemos un vistazo más de cerca al método fillTank en la clase Car

 public class Car() { private double tank; public Car() { tank = 0; } public void fillTank(double gallons) { tank = tank + gallons; } } 

En esta clase tenemos una variable de instancia “tanque”. Puede haber muchos objetos que usan la variable de instancia del tanque, para especificar que la variable de instancia “tanque” se usa para un objeto particular, en nuestro caso el objeto “audi” que construimos anteriormente, usamos la palabra reservada this . por ejemplo, variables, el uso de ‘this’ en un método indica que la variable de instancia, en nuestro caso “tank”, es la variable de instancia del parámetro implícito.

El comstackdor de Java agrega automáticamente this palabra reservada para que no tenga que agregarla, es una cuestión de preferencia. No puede usar this sin un punto (.) Porque esas son las reglas de java (la syntax).

En resumen.

  • Los objetos se definen por clases y tienen métodos y variables
  • El uso de this en una variable de instancia en un método indica que, la variable de instancia pertenece al parámetro implícito, o que es una variable de instancia del parámetro implícito.
  • El parámetro implícito es el objeto desde el que se llama al método, en este caso, “audi”.
  • El comstackdor de Java agrega automáticamente esta palabra reservada, agregando que es una cuestión de preferencia
  • this no se puede usar sin un punto (.) esto es sintácticamente inválido
  • this también se puede usar para distinguir entre variables locales y variables globales que tienen el mismo nombre
  • this palabra reserva también se aplica a los métodos, para indicar que un método pertenece a un objeto particular.

esto se puede usar dentro de algún método o constructor.

Devuelve la referencia al objeto actual.

La palabra clave this se usa para referirse a la variable actual de un bloque, por ejemplo, considere el siguiente código (solo un ejemplo, entonces no espere el código JAVA estándar):

 Public class test{ test(int a) { this.a=a; } Void print(){ System.out.println(a); } Public static void main(String args[]){ test s=new test(2); s.print(); } } 

Eso es. la Salida será “2”. Si no usamos la palabra clave this , entonces la salida será: 0

Una búsqueda rápida en Google trajo este resultado: http://xahlee.org/java-a-day/this.html

Prácticamente, la palabra clave “this” es una referencia al objeto actual (en sí mismo).

También estaba buscando la misma respuesta, y de alguna manera no podía entender el concepto claramente. Pero finalmente lo entendí desde este enlace

esta es una palabra clave en Java. Que se puede usar dentro del método o constructor de clase. Esto (esto) funciona como una referencia a un objeto actual cuyo método o constructor se está invocando. esta palabra clave se puede usar para referir cualquier miembro de un objeto actual desde un método de instancia o un constructor.

Verifique los ejemplos en el enlace para una comprensión clara

Si las variables de instancia son las mismas que las variables que se declaran en el constructor, usamos “this” para asignar datos.

 class Example{ int assign;// instance variable Example(int assign){ // variable inside constructor this.assign=assign; } } 

Espero que esto ayude.

En Java, “this” es una variable predefinida. Si usamos “this” en el método que significa que estamos obteniendo la referencia (dirección) del objeto que se está ejecutando actualmente. Para un ejemplo.

this.age —> edad del objeto que se está ejecutando actualmente.

Las variables de instancia son comunes a todos los objetos que se crean. decir, hay dos variables de instancia

 class ExpThisKeyWord{ int x; int y; public void setMyInstanceValues(int a, int b) { x= a; y=b; System.out.println("x is ="+x); System.out.println("y is ="+y); } } class Demo{ public static void main(String[] args){ ExpThisKeyWord obj1 = new ExpThisKeyWord(); ExpThisKeyWord obj2 = new ExpThisKeyWord(); ExpThisKeyWord obj3 = new ExpThisKeyWord(); obj1.setMyInstanceValues(1, 2); obj2.setMyInstanceValues(11, 22); obj3.setMyInstanceValues(111, 222); } } 

si notó el código anterior, hemos iniciado tres objetos y tres objetos están llamando al método SetMyInstanceValues. ¿Cómo crees que JVM asigna correctamente los valores para cada objeto? existe el truco, JVM no verá este código como se muestra arriba. en lugar de eso, verá el código siguiente;

 public void setMyInstanceValues(int a, int b) { this.x= a; //Answer: this keyword denotes the current object that is handled by JVM. this.y=b; System.out.println("x is ="+x); System.out.println("y is ="+y); } 

(Sé que llegué tarde, pero shh soy el boi furtivo que nunca me viste)

La palabra clave this en la mayoría de los lenguajes de progtwigción orientados a objetos, si no todos, significa que es una referencia hacia la instancia de objeto actual de esa clase. Es esencialmente lo mismo que invocar ese objeto desde fuera del método por su nombre. Eso probablemente no tenía sentido, así que elaboraré:

Fuera de la clase, para llamar a algo dentro de esa instancia del objeto, por ejemplo decir que tienes un objeto llamado objeto y quieres obtener un campo que necesitarías usar

 object.field 

Digamos, por ejemplo, que está intentando acceder a object.field desde el interior de su clase, por ejemplo, su constructor, por ejemplo, puede usar

 this.field 

La palabra clave this reemplaza esencialmente la palabra clave del nombre del objeto cuando se llama dentro de la clase. Por lo general, no hay muchas razones para hacer esto fuera de si tiene dos variables del mismo nombre, una de las cuales es un campo de la clase y la otra solo una variable dentro de un método, ayuda a descifrar entre las dos . Por ejemplo, si tienes esto: (Ja, ¿entiendes? Esto ? Hehe … ¿solo yo? Está bien 🙁 Me iré ahora)

 public String Name; //Constructor for {object} class public object(String Name){ Name = Name; } 

Eso causaría algunos problemas, el comstackdor no podría saber la diferencia entre la variable Name definida en los parámetros para el constructor y la variable Name dentro de las declaraciones de campo de su clase, por lo que en su lugar asignaría el parámetro Name a … .. el valor del parámetro Name que no hace nada beneficioso y literalmente no tiene ningún propósito. Este es un problema común que hacen la mayoría de los progtwigs más nuevos y yo también fui una víctima. De todos modos, la forma correcta de definir este parámetro sería usar:

 public String Name; //Constructor for {object} class public object(String Name){ this.Name = Name; } 

De esta forma, el comstackdor sabe que la variable Name que está intentando asignar es una parte de la clase y no una parte del método y la asigna correctamente, lo que significa que asigna el campo Name a todo lo que ponga en el constructor.

Para resumir, esencialmente hace referencia a un campo de la instancia de objeto de la clase en la que está trabajando, por lo tanto, es la palabra clave “this”, lo que significa que es este objeto o esta instancia. Es una buena práctica usar esto al llamar a un campo de su clase en lugar de simplemente usar el nombre para evitar posibles errores que son difíciles de encontrar cuando el comstackdor corre sobre ellos.