Quando devo usar "this" em uma classe?

Eu sei que thisse refere a um objeto atual. Mas não sei quando realmente preciso usá-lo. Por exemplo, haverá alguma diferença se eu usar em xvez de this.xem alguns dos métodos? Pode ser que xse refere a uma variável que é local para o método considerado? Quero dizer variável que é vista apenas neste método.

Que tal this.method()? Posso usá-lo? Devo usá-lo. Se eu apenas usar method(), não será, por padrão, aplicado ao objeto atual?

A thispalavra-chave é usada principalmente em três situações. O primeiro e mais comum é nos métodos setter para desambiguar referências de variáveis. A segunda é quando há a necessidade de passar a instância atual da classe como argumento para um método de outro objeto. A terceira é uma maneira de chamar construtores alternativos de dentro de um construtor.

Caso 1: Usando thispara desambiguar referências de variáveis. Nos métodos Java setter, geralmente passamos um argumento com o mesmo nome da variável de membro privado que estamos tentando definir. Em seguida, atribuímos o argumento xa this.x. Isso deixa claro que você está atribuindo o valor do parâmetro "name" à variável de instância "name".

public class Foo
{
    private String name;

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

Caso 2: usando thiscomo argumento passado para outro 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 thispara chamar construtores alternativos. Nos comentários, trinithis apontou corretamente outro uso comum de this. Quando você tem vários construtores para uma única classe, pode this(arg0, arg1, ...)chamar outro construtor de sua escolha, desde que faça isso na primeira linha do construtor.

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

        //optional other lines
    }

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

Eu também vi thisusado para enfatizar o fato de que uma variável de instância está sendo referenciada (sem a necessidade de desambiguação), mas esse é um caso raro na minha opinião.

O segundo uso importante de this(além de ocultar com uma variável local, como muitas respostas já dizem) é ao acessar uma instância externa de uma classe não estática aninhada:

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;
    }
  }
}

Você só precisa usar this- e a maioria das pessoas usa - quando há uma variável local sobreposta com o mesmo nome. (Métodos setter, por exemplo.)

Obviamente, outro bom motivo para usar thisé que ele faz com que o intellisense apareça nos IDEs :)

A única necessidade de usar o this.qualificador é quando outra variável no escopo atual compartilha o mesmo nome e você deseja consultar o membro da instância (como William descreve). Além disso, não há diferença de comportamento entre xe this.x.

"this" também é útil ao chamar um construtor de outro:

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

this é útil no padrão do construtor.

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();
    }

}

Há muitas boas respostas, mas há outra razão muito menor para colocar em thistodo lugar. Se você tentou abrir seus códigos-fonte a partir de um editor de texto normal (por exemplo, bloco de notas, etc.), o uso thisserá muito mais claro de se ler.

Imagina isto:

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;
        }
    }
}

Isso é muito claro para ler com qualquer IDE moderno, mas será um pesadelo total ler com um editor de texto comum.

Você lutará para descobrir onde fooreside, até usar a função "localizar" do editor. Então você gritará pelo getStringFromSomewhere()mesmo motivo. Por fim, depois de esquecer o que sé, isso bar = slhe dará o golpe final.

Compare com isso:

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

1. Você sabe que fooé uma variável declarada na classe externa Hello.
2. Você sabe que getStringFromSomewhere()é um método declarado na classe externa também.
3. Você sabe que barpertence à Worldclasse e sé uma variável local declarada nesse método.

Obviamente, sempre que você cria algo, você cria regras. Portanto, ao projetar sua API ou projeto, se suas regras incluírem "se alguém abrir todos esses códigos-fonte com um bloco de notas, ele ou ela deve dar um tiro na cabeça", você estará totalmente bem em não fazer isso .

A menos que você tenha nomes de variáveis ​​sobrepostos, é realmente apenas uma questão de clareza ao ler o código.

A resposta de @William Brendel forneceu três casos de uso diferentes de maneira agradável.

Caso de uso 1:

Página de documentação java oficial sobre este fornece mesmos casos de uso.

Dentro de um método de instância ou construtor, essa é uma referência ao objeto atual - o objeto cujo método ou construtor está sendo chamado. Você pode se referir a qualquer membro do objeto atual de dentro de um método de instância ou de um construtor usando isso.

Abrange dois exemplos:

Usando isso com um campo e Usando isso com um construtor

Caso de uso 2:

Outro caso de uso que não foi citado nesta postagem: thispode ser usado para sincronizar o objeto atual em um aplicativo multithread para proteger a seção crítica de dados e métodos.

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

Caso de uso 3:

A implementação do padrão Builder depende do uso de thispara retornar o objeto modificado.

Consulte este post

Mantendo o Construtor em Classe Separada (Interface Fluente)

O Google apareceu uma página no site da Sun que discute isso um pouco.

Você está certo sobre a variável; thispode realmente ser usado para diferenciar uma variável de método de um campo de classe.

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

No entanto, eu realmente odeio essa convenção. Dar duas variáveis ​​diferentes nomes literalmente idênticos é uma receita para bugs. Eu prefiro algo como:

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

Mesmos resultados, mas sem chance de um bug ao qual você se refere acidentalmente xquando realmente pretendia se referir x.

Quanto a usá-lo com um método, você está certo sobre os efeitos; você obterá os mesmos resultados com ou sem. Você pode usá-lo? Certo. Você deveria usá-lo? Depende de você, mas considerando que pessoalmente acho que é uma verbosidade sem sentido que não adiciona nenhuma clareza (a menos que o código esteja repleto de instruções de importação estáticas), não estou inclinado a usá-lo.

A seguir estão as maneiras de usar a palavra-chave 'this' em java:

1. Usando thispalavra-chave para referenciar variáveis ​​de instância de classe atual
2. Usando this()para invocar o construtor de classe atual
3. Usando thispalavra-chave para retornar a instância de classe atual
4. Usando thispalavra-chave como parâmetro de método

https://docs.oracle.com/javase/tutorial/java/javaOO/thiskey.html

quando existem duas variáveis, uma variável de instância e outra variável local com o mesmo nome, usamos isso. para referir o objeto em execução atual para evitar o conflito entre os nomes.

thisé uma referência ao objeto atual. É usado no construtor para distinguir entre a variável de classe local e a atual que tem o mesmo nome. por exemplo:

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

thistambém pode ser usado para chamar um construtor de outro construtor. por exemplo:

public class circle {
    int x;

    circle() { 
        this(1);
    }

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

Haverá alguma diferença se eu usar "x" em vez de "this.x" em alguns dos métodos?

Geralmente não. Mas às vezes faz diferença:

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

Se eu apenas usar "method ()", não será, por padrão, aplicado ao objeto atual?

Sim. Mas, se necessário, this.method()esclarece que a chamada é feita por esse objeto.

thisnão afeta o código resultante - é o operador de tempo de compilação e o código gerado com ou sem será o mesmo. Quando você precisa usá-lo, depende do contexto. Por exemplo, você deve usá-lo, como disse, quando tiver uma variável local que oculta a variável de classe e desejar consultar a variável de classe e não a local.

edit: por "o código resultante será o mesmo", claro, quando alguma variável no escopo local não oculta a que pertence à classe. portanto

class POJO {
   protected int i;

   public void modify() {
      i = 9;
   }

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

o código resultante de ambos os métodos será o mesmo. A diferença será se algum método declarar variável local com o mesmo nome

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

Com relação à pergunta dos posts e dbconfessions de William Brendel , referente ao caso 2 . Aqui está um exemplo:

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");
    }
  }

}

Eu já vi isso usado, ao criar relações pai-filho com objetos. No entanto, observe que é simplificado por uma questão de brevidade.

A palavra-chave “This” em java é usada para referenciar objetos de classe atuais.

Existem 6 usos da palavra-chave "this" em java

1. Acessando variável de nível de classe : usado principalmente se a variável local e de nível de classe for a mesma
2. Acessando métodos de classe : esse é o comportamento padrão e pode ser ignorado
3. Para chamar outro construtor da mesma classe
4. Usando a palavra-chave 'this' como valor de retorno : para retornar a instância atual do método
5. Passando a palavra-chave 'this' como argumento para o método Passing: para passar a instância da classe atual como argumento
6. esta palavra-chave como argumento para o construtor : para passar a instância atual da classe como argumento

ref: https://stacktraceguru.com/java/this-keyword-in-java

Para garantir que os membros do objeto atual sejam usados. Nos casos em que a segurança do encadeamento é uma preocupação, alguns aplicativos podem alterar os valores do membro de objetos incorretos; por esse motivo, isso deve ser aplicado ao membro para que o valor correto do membro do objeto seja usado.

Se o seu objeto não estiver preocupado com a segurança do encadeamento, não há motivo para especificar qual valor do membro do objeto será usado.