Java – quando usar a palavra-chave ‘this’

Qual é a melhor prática para usar a palavra this chave this em Java? Por exemplo, eu tenho a seguinte class:

 class Foo { Bar bar; public Foo(Bar bar) { this.bar = bar; } } 

Tudo bem, mas Java é inteligente o bastante para saber o que está acontecendo se eu mudar a declaração no construtor para

  bar = bar; 

Então, por que usar a palavra this chave this ? (Eu percebo que em algumas situações, é totalmente necessário usá-lo, estou apenas pedindo situações como essa). Na verdade, eu uso a palavra-chave apenas por questões de legibilidade, mas qual é a prática comum? Usá-lo por toda a loja faz meu código parecer um pouco confuso, por exemplo

 boolean baz; int someIndex = 5; this.baz = this.bar.getSomeNumber() == this.someBarArray[this.someIndex].getSomeNumber(); 

Obviamente, um pouco de código, mas ilustra o meu exemplo. É apenas por preferência pessoal nestes casos?

mas Java é inteligente o suficiente para saber o que está acontecendo se eu mudar a instrução no construtor para

  bar = bar; 

FALSO! Compila, mas não faz o que você acha que faz!

Quanto a quando usá-lo, muito disso é preferência pessoal. Eu gosto de usar this em meus methods públicos, mesmo quando é desnecessário, porque é onde a interface acontece e é bom afirmar o que é meu e o que não é.

Como referência, você pode verificar os Tutoriais Java do Oracle sobre this.subject 😉

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

Você deve usá-lo quando tiver um parâmetro com o mesmo nome de um campo, caso contrário, você terá problemas. Ele irá compilar, mas não necessariamente fará o que você quer.

Quanto a qualquer outro lugar, não use a menos que seja necessário para facilitar a leitura. Se você usá-lo em todos os lugares, 20% do seu código consistirá da palavra “this”!

Na realidade

 baz = baz 

vai levantar esse aviso

A atribuição da variável baz não tem efeito

Então, o que você acha que está errado, o escopo local substitui o atributo de class, então você DEVE usar this palavra this chave explicitamente para atribuir a variável ao atributo de class.

Caso contrário, a variável contabilizada em atribuição é apenas a que foi passada como parâmetro e a class um é ignorada. É por this que this é útil, não é um fato de legibilidade, é um fato de decidir explicitamente de que baz você está falando.

eu diria

usar this onde quer que não o use causaria ambigüidades (ou aviso de compilador, que são mais importantes), caso contrário, simplesmente deixe-o. Já que seu propósito é exatamente resolver ambiguidades quando suposições padrão (primeiro verificar locais, então verificar atributos de classs) não são suficientes.

this palavra this chave se refere ao object da class no qual algum método é chamado.
Por exemplo:

 public class Xyz { public Xyz(Abc ob) { ob.show(); } } public class Abc { int a = 10; public Abc() { new Xyz(this); } public void show() { System.out.println("Value of a " + a); } public static void main(String s[]) { new Abc(); } } 

Aqui no Abc() estamos chamando Xyz() que precisa do Objeto da Classe Abc .. Então podemos passar this invés do novo Abc() , pois se passarmos novo Abc() aqui ele irá se chamar novamente e novamente.

Também usamos isso para diferenciar variables ​​de class e variables ​​locais de método. por exemplo

 class Abc { int a; void setValue(int a) { this.a = a; } } 

Aqui this.a refere-se à variável a da class Abc. Daí ter o mesmo efeito que você usa o novo Abc().a; .

Então você pode dizer que this se refere ao object da class atual.

É comum usar essa palavra chave na chamada explícita do construtor . Você pode ver um exemplo da documentação .

 public class Rectangle { private int x, y; private int width, height; public Rectangle() { this(0, 0, 1, 1); } public Rectangle(int width, int height) { this(0, 0, width, height); } public Rectangle(int x, int y, int width, int height) { this.x = x; this.y = y; this.width = width; this.height = height; } ... } 
 public Foo(Bar bar) { this.bar = bar; } 

não é o mesmo que

 public Foo(Bar bar) { bar = bar; } 

No segundo caso, a barra no escopo é o parâmetro, então você a atribui a si mesmo. this.bar permanece null .

É uma preferência pessoal – escolha um estilo e cumpra-o. Eu pessoalmente uso this mas outros pensam que é redundante.

Dependendo da convenção, você pode usá-lo para facilitar a leitura. Ele enfatiza o fato de que é uma variável de object.

Eu também gosto de ter argumentos setter com o mesmo nome que a variável (parece melhor na assinatura do método). Você precisa this neste caso.

Eu sempre tento usar this palavra-chave em objects de class local.

Eu o uso para me lembrar visualmente se um object é object estático ou object de class.

Isso me ajuda e o compilador diferencia entre argumentos de método e object de class local.

 public void setValue(int value){ this.value = value; } 

Isso me ajuda a me lembrar visualmente se existe um object local em uma class interna / aninhada / anônima para diferenciá-lo dos objects de class de encapsulamento. Porque se não houver this prefixo, minha convenção vai me lembrar que é um object da class encapsulante

 public class Hello{ public int value = 0; public boolean modal = false; public class Hellee{ public int value = 1; public getValue(){ if (modal) return 0; return this.value; } } } 
 void set(int real) { this.real = real; } 

aqui this é uma palavra chave usada quando há uma variável de instância igual à variável local.
outro uso this é a sobrecarga do construtor. ele pode chamar o construtor em um construtor sobrecarregado.

Preferência pessoal, mas eu a utilizo apenas para resolver ambiguidades, e suponho que no caso muito raro tornar óbvio que a variável designada é um campo. Existem alguns projetos em que as pessoas usam “this.field” em todas as referências de campo. Eu acho esta prática visualmente distrativa a ponto de ser desagradável, mas você deve estar preparado para ver esse código de vez em quando.

Eu secretamente acho que há um lugar especial no inferno para as pessoas que escrevem 500 aulas de linha que têm 275 palavras-chave ‘nelas’ nelas, mas esse estilo é encontrado em alguns projetos de código aberto, então para cada um deles, eu acho.

Use-o para Clonar objects (passando referência de si mesmo através de um construtor de cópia).

Útil para o object que herda Cloneable .

 public Foo implements Cloneable { private String bar; public Foo(Foo who) { bar = who.bar; } public Object getClone() { return new Foo(this); //Return new copy of self. } }