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

Normalmente, lo uso thissolo en constructores.

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

Sin embargo, no sé cuál es el verdadero significado de thisJava y qué sucederá si lo uso thissin punto ( .).

this se 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
  }
}

Entonces llamando frobnicate()en new MyThisTest()imprimirá

1
42
MyThisTest a = 42

Así que efectivamente lo usas para múltiples cosas:

• aclare que está 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
• invoque a 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 la thispalabra clave:

Definición: La thispalabra clave 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 denotar específicamente que se usa 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 precedencia es alta para la variable local. Por lo tanto, la ausencia de thisdenota 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 thisse usa o no, indica la variable de instancia.

2. This se usa para referir a los constructores

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

   Esto invoca al constructor de la misma clase java que tiene dos parámetros.

3. This se utiliza para pasar la instancia de 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 identificador 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, thisestá asociado con su instancia y esto no funcionará en métodos estáticos.

Para completar, thistambié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 en particular, por lo que podría escribir algo como

public Object getMe() {
    return this;
}

Un caso de uso común thises evitar el sombreado. Tome 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 utilizando el valor del parámetro. Como comparten el mismo nombre, necesitamos una forma de distinguir entre el campo y el parámetro. thisnos permite acceder a 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 ActionListenery agregue la instancia actual (es decir, 'esto') como 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!");
    }

}

Es "una referencia al objeto en el contexto actual" de manera efectiva. Por ejemplo, para imprimir "este objeto" podría escribir:

System.out.println(this);

Tenga en cuenta que su uso de "variable global" está algo apagado ... si lo está utilizando this.variableName, por definición, no es una variable global, es una variable específica de esta instancia en particular.

Citando un artículo en programming.guide:

thistiene dos usos en un programa Java.

1. Como referencia al objeto actual

La sintaxis en este caso generalmente se parece a

this.someVariable = someVariable;

Este tipo de uso se describe aquí: la referencia 'this' (con ejemplos)

2. Llamar a un constructor diferente.

La sintaxis en este caso generalmente se parece a

MyClass() {
    this(DEFAULT_VALUE); // delegate to other constructor
}

MyClass(int value) {
    // ...
}

Este tipo de uso se describe aquí: esta (…) llamada de constructor (con ejemplos)

Se refiere a la instancia en la que se llama al 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

La palabra clave this se usa para referir la variable actual de un bloque, por ejemplo, considere el siguiente código (solo un ejemplo, así que 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 utilizamos esta palabra clave, la salida será: 0

Los objetos tienen métodos y atributos (variables) que se derivan de las clases, para especificar qué métodos y variables pertenecen a un objeto en particular thisse utiliza la palabra reservada. En el caso de las variables de instancia, es importante comprender la diferencia entre los parámetros implícitos y explícitos. Echa un vistazo a la fillTankllamada del audiobjeto.

Car audi= new Car();

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

El valor entre 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 fillTankmétodo tiene un parámetro explícito y uno implícito.

Veamos más de cerca el fillTankmétodo en la Carclase.

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". Podría haber muchos objetos que usan la variable de instancia de tanque, para especificar que la variable de instancia "tanque" se usa para un objeto en particular, en nuestro caso el objeto "audi" que construimos anteriormente, usamos la thispalabra clave reservada. para las variables de instancia, el uso de 'this' en un método indica que la variable de instancia, en nuestro caso "tanque", es la variable de instancia del parámetro implícito.

El compilador de Java agrega automáticamente la thispalabra reservada para que no tenga que agregarla, es una cuestión de preferencia. No se puede usar thissin un punto (.) Porque esas son las reglas de Java (la sintaxis).

En resumen.

• Los objetos se definen por clases y tienen métodos y variables.
• El uso de thisuna 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 el método en este caso "audi".
• El compilador 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
• la thispalabra de reserva también se aplica a los métodos, para indicar que un método pertenece a un objeto en particular.

Las variables de instancia son comunes a cada objeto que está creando. digamos, 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? ahí está el truco, JVM no verá este código como se muestra arriba. en lugar de eso, verá el siguiente código;

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 llego tarde pero shh estoy siendo el chico astuto que nunca me viste)

La palabra clave this en la mayoría de los lenguajes de programació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 llamar a 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 tiene un objeto llamado objeto y desea obtener un campo que necesitaría usar

object.field

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

this.field

La palabra clave this esencialmente reemplaza la palabra clave del nombre del objeto cuando se llama dentro de la clase. Por lo general, no hay muchas razones para hacerlo si tiene dos variables con el mismo nombre, una de las cuales es un campo de la clase y la otra es solo una variable dentro de un método, ayuda a descifrar entre las dos . Por ejemplo, si tienes esto: (Ja, ¿entiendes? ¿ Esto ? Jeje ... ¿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 compilador no podría saber la diferencia entre la variable Nombre definida en los parámetros para el constructor y la variable Nombre dentro de las declaraciones de campo de su clase, por lo que en su lugar asignaría el parámetro Nombre a ... .. el valor del parámetro Nombre que no hace nada beneficioso y literalmente no tiene ningún propósito. Este es un problema común que la mayoría de los programas más nuevos hacen y yo también fui 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 manera, el compilador sabe que la variable Nombre que está tratando de asignar es parte de la clase y no parte del método y la asigna correctamente, lo que significa que asigna el campo Nombre a lo que haya puesto en el constructor.

Para resumir, esencialmente hace referencia a un campo de la instancia del 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 cuando se llama 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 compilador se ejecuta directamente sobre ellos.

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

Casi la palabra clave "this" es una referencia al objeto actual (en sí mismo).

thises una referencia al objeto actual: http://download.oracle.com/javase/tutorial/java/javaOO/thiskey.html

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

Devuelve la referencia al objeto actual.

Esto se refiere al objeto en el que estás "ahora". En otras palabras, esto se refiere al objeto receptor. Usas esto para aclarar a qué variable te refieres. Página de Java_whitepaper: 37

class Point extends Object
{
    public double x;
    public double y;

    Point()
    {
        x = 0.0;
        y = 0.0;
    }

    Point(double x, double y)
    {
        this.x = x;
        this.y = y;
    }
}

En el código de ejemplo anterior this.x / this.y se refiere a la clase actual que es Variables de clase de punto x e y donde (doble x, doble y) son valores dobles pasados ​​de una clase diferente para asignar valores a la clase actual.

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) funciona como una referencia a un objeto actual cuyo método o constructor está siendo invocado. esta palabra clave se puede usar para referir a cualquier miembro del objeto actual desde un método de instancia o un constructor.

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

Si las variables de instancia son las mismas que las declaradas en el constructor, entonces 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 "esto" es una variable predefinida. Si usamos "this" en el método, eso significa que estamos obteniendo la referencia (dirección) del objeto actualmente en ejecución. Para un ejemplo.

this.age ---> edad del objeto actualmente en ejecución.

Me gustaría compartir lo que entendí de esta palabra clave. Esta palabra clave tiene 6 usos en java de la siguiente manera: -

1. Se puede utilizar para referirse a la variable de clase actual. Déjanos entender con un código. *

Comprendamos el problema si no usamos esta palabra clave en el ejemplo que se muestra a continuación:

class Employee{  
int id_no;  
String name;  
float salary;  
Student(int id_no,String name,float salary){  
id_no = id_no;  
name=name;  
salary = salary;  
}  
void display(){System.out.println(id_no +" "+name+" "+ salary);}  
}  
class TestThis1{  
public static void main(String args[]){  
Employee s1=new Employee(111,"ankit",5000f);  
Employee s2=new Employee(112,"sumit",6000f);  
s1.display();  
s2.display();  
}}  

Salida:-

0 null 0.0
0 null 0.0

En el ejemplo anterior, los parámetros (argumentos formales) y las variables de instancia son iguales. Entonces, estamos usando esta palabra clave para distinguir la variable local y la variable de instancia.

class Employee{  
int id_no;  
String name;  
float salary;  
Student(int id_no,String name,float salary){  
this.id_no = id_no;  
this.name=name;  
this.salary = salary;  
}  
void display(){System.out.println(id_no +" "+name+" "+ salary);}  
}  
class TestThis1{  
public static void main(String args[]){  
Employee s1=new Employee(111,"ankit",5000f);  
Employee s2=new Employee(112,"sumit",6000f);  
s1.display();  
s2.display();  
}} 

salida:

111 ankit 5000
112 sumit 6000

2. Invocar el método de clase actual.

class A{  
void m(){System.out.println("hello Mandy");}  
void n(){  
System.out.println("hello Natasha");  
//m();//same as this.m()  
this.m();  
}  
}  
class TestThis4{  
public static void main(String args[]){  
A a=new A();  
a.n();  
}}  

Salida:

hello Natasha
hello Mandy

3. invocar el constructor de clase actual. Se utiliza para encadenar constructores.

class A{  
A(){System.out.println("hello ABCD");}  
A(int x){  
this();  
System.out.println(x);  
}  
}  
class TestThis5{  
public static void main(String args[]){  
A a=new A(10);  
}}

Salida:

hello ABCD
10

4. pasar como argumento en el método.

class S2{  
  void m(S2 obj){  
  System.out.println("The method is invoked");  
  }  
  void p(){  
  m(this);  
  }  
  public static void main(String args[]){  
  S2 s1 = new S2();  
  s1.p();  
  }  
}  

Salida:

The method is invoked

5. pasar como argumento en la llamada al constructor

class B{  
  A4 obj;  
  B(A4 obj){  
    this.obj=obj;  
  }  
  void display(){  
    System.out.println(obj.data);//using data member of A4 class  
  }  
}  

class A4{  
  int data=10;  
  A4(){  
   B b=new B(this);  
   b.display();  
  }  
  public static void main(String args[]){  
   A4 a=new A4();  
  }  
} 

Salida:-

10

6. para devolver la instancia de clase actual

class A{  
A getA(){  
return this;  
}  
void msg(){System.out.println("Hello");}  
}  
class Test1{  
public static void main(String args[]){  
new A().getA().msg();  
}  
}  

Salida:-

Hello

Además, esta palabra clave no se puede usar sin. (Punto) ya que su sintaxis no es válida.