programming - what is an object in java

¿Cuándo debo usar "esto" en una clase?

Question

Sé que this refiere a un objeto actual. Pero no sé cuándo realmente necesito usarlo. Por ejemplo, ¿habrá alguna diferencia si utilizo x lugar de this.x en algunos de los métodos? ¿Puede ser x referirse a una variable que es local para el método considerado? Me refiero a la variable que se ve sólo en este método.

¿Qué hay de este. this.method() ? ¿Puedo usarlo? Debería usarlo. Si solo uso el method() , ¿no se aplicará, de forma predeterminada, al objeto actual?

Answer 1

"esto" también es útil cuando se llama a un constructor desde otro:

public class MyClass {
    public MyClass(String foo) {
        this(foo, null);
    }
    public MyClass(String foo, String bar) {
        ...
    }
}

Answer 2

¿Habrá alguna diferencia si utilizo "x" en lugar de "this.x" en algunos de los métodos?

Usualmente no. Pero a veces hace la diferencia:

  class A {
     private int i;
     public A(int i) {
        this.i = i; // this.i can be used to disambiguate the i being referred to
     }
  }

Si solo uso "method ()", ¿no se aplicará, de forma predeterminada, al objeto actual?

Sí. Pero si es necesario, this.method() aclara que este objeto realiza la llamada.

Answer 3

A menos que tenga nombres de variables superpuestos, es realmente solo para claridad cuando está leyendo el código.

Answer 4

Con respecto a los mensajes de William Brendel y la pregunta de dbconfession , con respecto al caso 2 . Aquí hay un ejemplo:

public class Window {

  private Window parent;

  public Window (Window parent) {
    this.parent = parent;
  }

  public void addSubWindow() {
    Window child = new Window(this);
    list.add(child);
  }

  public void printInfo() {
    if (parent == null) {
      System.out.println("root");
    } else {
      System.out.println("child");
    }
  }

}

He visto esto usado, al construir relaciones padre-hijo con objetos. Sin embargo, tenga en cuenta que se simplifica por razones de brevedad.

Answer 5

El segundo uso importante de this (además de ocultarse con una variable local como ya lo dicen muchas respuestas) es cuando se accede a una instancia externa desde una clase no estática anidada:

public class Outer {
  protected int a;

  public class Inner {
    protected int a;

    public int foo(){
      return Outer.this.a;
    }

    public Outer getOuter(){
      return Outer.this;
    }
  }
}

Answer 6

Hay muchas respuestas buenas, pero hay otra razón muy pequeña para poner this todas partes. Si ha intentado abrir sus códigos fuente desde un editor de texto normal (p. Ej., Un bloc de notas, etc.), usarlo hará que sea mucho más claro de leer.

Imagina esto:

public class Hello {
    private String foo;

    // Some 10k lines of codes

    private String getStringFromSomewhere() {
        // ....
    }

    // More codes

    public class World {
        private String bar;

        // Another 10k lines of codes

        public void doSomething() {
            // More codes
            foo = "FOO";
            // More codes
            String s = getStringFromSomewhere();
            // More codes
            bar = s;
        }
    }
}

Esto es muy claro para leer con cualquier IDE moderno, pero esto será una pesadilla total para leer con un editor de texto regular.

Tendrá dificultades para averiguar dónde reside foo , hasta que utilice la función de "búsqueda" del editor. Entonces getStringFromSomewhere() en getStringFromSomewhere() por la misma razón. Finalmente, una vez que hayas olvidado qué es s , esa bar = s te dará el golpe final.

Compáralo con esto:

public void doSomething() {
    // More codes
    Hello.this.foo = "FOO";
    // More codes
    String s = Hello.this.getStringFromSomewhere();
    // More codes
    this.bar = s;
}

1. Sabes que foo es una variable declarada en la clase externa Hello .
2. Usted sabe que getStringFromSomewhere() es un método declarado en la clase externa.
3. Usted sabe que la bar pertenece a World clase World , y s es una variable local declarada en ese método.

Por supuesto, cada vez que diseñas algo, creas reglas. Entonces, al diseñar su API o proyecto, si sus reglas incluyen "si alguien abre todos estos códigos fuente con un bloc de notas, debería dispararse a sí mismo en la cabeza", entonces está totalmente en condiciones de no hacer esto .

Answer 7

La única necesidad de usar this. calificador es cuando otra variable dentro del alcance actual comparte el mismo nombre y usted quiere referirse al miembro de la instancia (como describe William). Aparte de eso, no hay diferencia en el comportamiento entre x y this.x

Answer 8

La respuesta de @William Brendel proporcionó tres casos de uso diferentes de manera agradable.

Caso de uso 1:

La página oficial de documentación de java sobre this proporciona los mismos casos de uso.

Dentro de un método de instancia o un constructor, esta es una referencia al objeto actual, el objeto cuyo método o constructor se está llamando. Puede referirse a cualquier miembro del objeto actual desde un método de instancia o un constructor usando esto.

Abarca dos ejemplos:

Usando esto con un campo y Usando esto con un constructor

Caso de uso 2:

Otro caso de uso que no se ha citado en esta publicación: se puede usar para sincronizar el objeto actual en una aplicación de subprocesos múltiples para proteger la sección crítica de datos y métodos.

synchronized(this){
    // Do some thing. 
}

Caso de uso 3:

La implementación del patrón Builder depende del uso de this para devolver el objeto modificado.

Refiera a este post

Mantener el constructor en clase separada (interfaz fluida)

Answer 9

Para asegurarse de que se utilizan los miembros del objeto actual. En los casos en que la seguridad de los subprocesos es una preocupación, algunas aplicaciones pueden cambiar los valores de los miembros de los objetos equivocados, por ese motivo, esto debe aplicarse al miembro para que se utilice el valor de miembro del objeto correcto.

Si su objeto no está preocupado por la seguridad de los subprocesos, no hay razón para especificar qué valor de miembro del objeto se utiliza.

Answer 10

Solo necesita usar this , y la mayoría de la gente lo usa, cuando hay una variable local superpuesta con el mismo nombre. (Métodos Setter, por ejemplo.)

Por supuesto, otra buena razón para usar this es que hace que aparezca inteligentemente en IDEs :)

Answer 11

cuando hay dos variables, una variable de instancia y otra variable local del mismo nombre, usamos esto. para referirse al objeto en ejecución actual para evitar el conflicto entre los nombres.

Answer 12

Google mostró una página en el sitio de Sun que discute esto un poco.

Tienes razón sobre la variable; this puede usarse para diferenciar una variable de método de un campo de clase.

private int x; public void setX(int x) { this.x=x; }

Sin embargo, realmente odio esa convención. Dar dos variables diferentes, literalmente, nombres idénticos es una receta para los errores. Prefiero algo a lo largo de las líneas de:

private int x; public void setX(int newX) { x=newX; }

Los mismos resultados, pero sin la posibilidad de un error en el que se refiera accidentalmente a x cuando realmente quería referirse a x lugar.

En cuanto a usarlo con un método, tienes razón sobre los efectos; Obtendrá los mismos resultados con o sin él. ¿Puedes usarlo? Por supuesto. ¿Deberías usarlo? Depende de usted, pero dado que personalmente creo que es una verbosidad sin sentido que no agrega claridad (a menos que el código esté repleto de declaraciones de importación estáticas), no estoy dispuesto a usarlo yo mismo.

Answer 13

this es útil en el patrón de constructor.

public class User {

    private String firstName;
    private String surname;

    public User(Builder builder){
        firstName = builder.firstName;
        surname = builder.surname;
    }

    public String getFirstName(){
        return firstName;
    }

    public String getSurname(){
        return surname;
    }

    public static class Builder {
        private String firstName;
        private String surname;

        public Builder setFirstName(String firstName) {
            this.firstName = firstName;
            return this;
        }

        public Builder setSurname(String surname) {
            this.surname = surname;
            return this;
        }

        public User build(){
            return new User(this);
        }

    }

    public static void main(String[] args) {
        User.Builder builder = new User.Builder();
        User user = builder.setFirstName("John").setSurname("Doe").build();
    }

}

Answer 14

this es una referencia al objeto actual. Se utiliza en el constructor para distinguir entre la variable de clase local y la actual que tienen el mismo nombre. p.ej:

public class circle {
    int x;
    circle(int x){
        this.x =x;
        //class variable =local variable 
    }
} 

this también se puede usar para llamar a un constructor desde otro constructor. p.ej:

public class circle {
    int x;

    circle() { 
        this(1);
    }

    circle(int x) {
        this.x = x; 
    }
}

Answer 15

this no afecta al código resultante: es un operador de tiempo de compilación y el código generado con o sin él será el mismo. Cuando tienes que usarlo, depende del contexto. Por ejemplo, debe usarlo, como dijo, cuando tiene una variable local que sombrea la variable de clase y desea referirse a una variable de clase y no a una local.

editar: por "el código resultante será el mismo" Quiero decir, por supuesto, cuando alguna variable en el ámbito local no oculta la que pertenece a la clase. Así

class POJO {
   protected int i;

   public void modify() {
      i = 9;
   }

   public void thisModify() {
      this.i = 9;
   }
}

El código resultante de ambos métodos será el mismo. La diferencia será si algún método declara una variable local con el mismo nombre.

  public void m() {
      int i;
      i = 9;  // i refers to variable in method''s scope
      this.i = 9; // i refers to class variable
  }

Answer 16

this palabra clave se utiliza principalmente en tres situaciones. El primero y el más común es en los métodos de establecimiento para desambiguar las referencias de variables. El segundo es cuando existe la necesidad de pasar la instancia de la clase actual como un argumento a un método de otro objeto. El tercero es como una forma de llamar a constructores alternativos desde dentro de un constructor.

Caso 1: Usando this para desambiguar las referencias de variables. En los métodos de establecimiento de Java, comúnmente pasamos un argumento con el mismo nombre que la variable miembro privada que intentamos establecer. Entonces le asignamos el argumento x a this.x Esto deja claro que está asignando el valor del parámetro "nombre" a la variable de instancia "nombre".

public class Foo
{
    private String name;

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

Caso 2: Usando this como un argumento pasado a otro objeto.

public class Foo
{
    public String useBarMethod() {
        Bar theBar = new Bar();
        return theBar.barMethod(this);
    }

    public String getName() {
        return "Foo";
    }
}

public class Bar
{
    public void barMethod(Foo obj) {
        obj.getName();
    }
}

Caso 3: Usando this para llamar constructores alternos. En los comentarios, trinithis señaló correctamente otro uso común de this . Cuando tiene varios constructores para una sola clase, puede usar this(arg0, arg1, ...) para llamar a otro constructor de su elección, siempre que lo haga en la primera línea de su constructor.

class Foo
{
    public Foo() {
        this("Some default value for bar");

        //optional other lines
    }

    public Foo(String bar) {
        // Do something with bar
    }
}

También he visto this usado para enfatizar el hecho de que se está haciendo referencia a una variable de instancia (sin la necesidad de desambiguación), pero ese es un caso raro en mi opinión.

Answer 17

Las siguientes son las formas de usar la palabra clave ''this'' en java:

1. Usando this palabra clave para referir variables de instancia de clase actual
2. Usando this() para invocar el constructor de la clase actual
3. Usando this palabra clave para devolver la instancia de clase actual
4. Usando this palabra clave como parámetro del método

this