Usando la palabra clave “this” en java

Estoy tratando de entender qué es realmente la palabra clave java. He estado leyendo la documentación de Sun, pero todavía estoy confundido sobre lo que realmente hace.

La palabra clave this es una referencia al objeto actual.

 class Foo { private int bar; public Foo(int bar) { // the "this" keyword allows you to specify that // you mean "this type" and reference the members // of this type - in this instance it is allowing // you to disambiguate between the private member // "bar" and the parameter "bar" passed into the // constructor this.bar = bar; } } 

Otra forma de pensarlo es que la palabra clave this es como un pronombre personal que usas para hacerte referencia. Otros idiomas tienen diferentes palabras para el mismo concepto. VB usa Me y la convención de Python (ya que Python no usa una palabra clave, simplemente un parámetro implícito para cada método) es usar self .

Si hicieras referencia a objetos que son intrínsecamente tuyos, dirías algo como esto:

Mi arm o mi pierna

Piense en this como solo una manera para que un tipo diga “mi”. Entonces, una representación de psuedocode se vería así:

 class Foo { private int bar; public Foo(int bar) { my.bar = bar; } } 

La palabra clave this puede significar cosas diferentes en diferentes contextos, esa es probablemente la fuente de su confusión.

Se puede usar como una referencia de objeto que se refiere a la instancia en la que se invocó el método actual: return this;

Se puede usar como una referencia de objeto que se refiere a la instancia que está creando el constructor actual, por ejemplo, para acceder a campos ocultos:

 MyClass(String name) { this.name = name; } 

Se puede usar para invocar un constructor diferente de una clase desde un constructor:

 MyClass() { this("default name"); } 

Se puede usar para acceder a las instancias adjuntas desde una clase anidada:

 public class MyClass { String name; public class MyClass { String name; public String getOuterName() { return MyClass.this.name; } } } 

“esto” es una referencia al objeto actual.

Ver detalles aquí

La palabra clave es una referencia al objeto actual . Se explica mejor con el siguiente fragmento de código:

 public class MyClass { public void testingThis() { // You can access the stuff below by // using this (although this is not mandatory) System.out.println(this.myInt); System.out.println(this.myStringMethod()); // Will print out: // 100 // Hello World } int myInt = 100; string myStringMethod() { return "Hello World"; } } 

No se usa mucho a menos que tengas un código estándar en tu lugar indicándote que uses la palabra clave this . Hay un uso común para él, y eso es si sigues una convención de código donde tienes nombres de parámetros que son los mismos que los atributos de tu clase:

 public class ProperExample { private int numberOfExamples; public ProperExample(int numberOfExamples) { this.numberOfExamples = numberOfExamples; } } 

Un uso adecuado de esta palabra clave es encadenar constructores (haciendo que la construcción de objetos sea consistente en todos los constructores):

 public class Square { public Square() { this(0, 0); } public Square(int x_and_y) { this(x_and_y, x_and_y); } public Square(int x, int y) { // finally do something with x and y } } 

Esta palabra clave funciona de la misma manera en, por ejemplo, C #.

Un mejor uso de esto

 public class Blah implements Foo { public Foo getFoo() { return this; } } 

Le permite específicamente “este” objeto en el contexto actual. Otro ejemplo:

 public class Blah { public void process(Foo foo) { foo.setBar(this); } } 

¿De qué otra forma podrías hacer estas operaciones?

“this” palabra clave se refiere al objeto actual debido a que el método está en ejecución. También se usa para evitar la ambigüedad entre la variable local pasada como argumento en un método y la variable de instancia siempre que la variable de instancia y la variable local tengan el mismo nombre.

Ejemplo ::

 public class ThisDemo1 { public static void main(String[] args) { A a1=new A(4,5); } } class A { int num1; int num2; A(int num1) { this.num1=num1; //here "this" refers to instance variable num1. //"this" avoids ambigutiy between local variable "num1" & instance variable "num1" System.out.println("num1 :: "+(this.num1)); } A(int num, int num2) { this(num); //here "this" calls 1 argument constructor within the same class. this.num2=num2; System.out.println("num2 :: "+(this.num2)); //Above line prints value of the instance variable num2. } } 

La palabra clave ‘ this ‘ se refiere al contexto del objeto actual. En muchos casos (como lo señala Andrew ), usará un explícito para aclarar que se está refiriendo al objeto actual.

Además, de ‘ esto y super ‘:

* Hay otros usos para esto. Algunas veces, cuando está escribiendo un método de instancia, necesita pasar el objeto que contiene el método a una subrutina, como un parámetro real. En ese caso, puede usar esto como el parámetro real. Por ejemplo, si desea imprimir una representación de cadena del objeto, podría decir “System.out.println (this);”. O puede asignar el valor de esto a otra variable en una statement de asignación.

De hecho, puede hacer cualquier cosa con esto que pueda hacer con cualquier otra variable, excepto cambiar su valor. *

Ese sitio también se refiere al concepto relacionado de ‘ super ‘, que puede resultar útil para comprender cómo funcionan con la herencia.

Es una referencia de instancia real de una clase dentro de un método de la misma clase. encoding

 public class A{ int attr=10; public int calc(){ return this.getA()+10; } /** *get and set **/ }//end class A 

En el cuerpo de calc () , el software ejecuta un método dentro del objeto asignado actualmente.

¿Cómo es posible que el comportamiento del objeto pueda verse a sí mismo? Con la palabra clave this , exactamente.

En realidad, la palabra clave this no requiere un uso obligatorio (como super ) porque la JVM sabe dónde llamar a un método en el área de la memoria, pero en mi opinión esto hace que el código sea más legible.

También puede ser una forma de acceder a la información en el contexto actual. Por ejemplo:

 public class OuterClass { public static void main(String[] args) { OuterClass oc = new OuterClass(); } OuterClass() { InnerClass ic = new InnerClass(this); } class InnerClass { InnerClass(OuterClass oc) { System.out.println("Enclosing class: " + oc + " / " + oc.getClass()); System.out.println("This class: " + this + " / " + this.getClass()); System.out.println("Parent of this class: " + this.getClass().getEnclosingClass()); System.out.println("Other way to parent: " + OuterClass.this); } } } 

Piénselo en términos de inglés, “este objeto” es el objeto que tiene actualmente.

 WindowMaker foo = new WindowMaker(this); 

Por ejemplo, actualmente se encuentra dentro de una clase que se extiende desde el JFrame y desea pasar una referencia al objeto WindowMaker para el JFrame para que pueda interactuar con el JFrame. Puede pasar una referencia al JFrame, pasando su referencia al objeto que se llama “this”.

Cada objeto puede acceder a una referencia a sí mismo con la palabra clave this (a veces llamada la referencia this).

Primero echemos un vistazo al código

 public class Employee { private int empId; private String name; public int getEmpId() { return this.empId; } public String getName() { return this.name; } public void setEmpId(int empId) { this.empId = empId; } public void setName(String name) { this.name = name; } 

}

En el método anterior getName () devuelve el nombre de la variable de instancia. Ahora vamos a echar otro vistazo de código similar es

 public class Employee { private int empId; private String name; public int getEmpId() { return this.empId; } public String getName() { String name="Yasir Shabbir"; return name; } public void setEmpId(int empId) { this.empId = empId; } public void setName(String name) { this.name = name; } public static void main(String []args){ Employee e=new Employee(); e.setName("Programmer of UOS"); System.out.println(e.getName()); } 

}

Salida Yasir Shabbir

  • este operador siempre trabaja con la variable de instancia (pertenecer a un objeto) no con ninguna variable de clase (pertenecer a la clase)
  • esto siempre se refiere al atributo de clase no estática, no a ningún otro parámetro o variable local.
  • esto siempre se usa en el método no estático
  • este operador no puede trabajar en la variable estática (variable de clase)

** NOTA: ** A menudo es un error lógico cuando un método contiene un parámetro o variable local que tiene el mismo nombre que un campo de la clase. En este caso, use referencia esto si desea acceder al campo de la clase; de ​​lo contrario, se hará referencia al parámetro del método o a la variable local.

Lo que ‘esto’ hace es muy simple. Tiene la referencia del objeto actual.

  • Esta palabra clave contiene la referencia de la instancia de la clase actual
  • Esta palabra clave no se puede usar dentro de la función estática o bloques estáticos
  • Esta palabra clave se puede usar para acceder a la variable sombreada de la instancia
  • Esta palabra clave se puede usar para pasar el objeto actual como parámetro en llamadas a funciones
  • Esta palabra clave se puede usar para crear una cadena de constructores

Fuente: http://javaandme.com/core-java/this-word