Java: quando utilizzare la parola chiave “this”

Qual è la migliore pratica per l’utilizzo di this parola chiave in Java? Ad esempio, ho la seguente class:

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

Va bene e tutto, ma Java è abbastanza intelligente da sapere cosa sta succedendo se cambio l’istruzione nel costruttore

  bar = bar; 

Quindi perché usare this parola chiave? (Mi rendo conto che in alcune situazioni è assolutamente necessario usarlo, sto solo chiedendo situazioni come questa). In realtà, io tendo ad usare la parola chiave puramente per motivi di leggibilità, ma qual è la pratica comune? Ad esempio, utilizzarlo in tutto il negozio rende il mio codice un po ‘disordinato

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

Ovviamente un po ‘di codice, ma illustra il mio esempio. È solo in base alle preferenze personali in questi casi?

ma Java è abbastanza intelligente da sapere cosa sta succedendo se cambio l’istruzione nel costruttore

  bar = bar; 

FALSO! Compila ma non fa quello che pensi che faccia!

Quanto a quando usarlo, molto è preferenza personale. Mi piace usare this nei miei metodi pubblici, anche quando non è necessario, perché è lì che avviene l’interfacciamento ed è bello affermare ciò che è mio e ciò che non lo è.

Come riferimento, puoi controllare i tutorial Java di Oracle su this.subject 😉

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

Dovresti usarlo quando hai un parametro con lo stesso nome di un campo altrimenti ti imbatterai in problemi. Compilerà, ma non farà necessariamente ciò che vorresti.

Come altrove, non usarlo a meno che non sia necessario per motivi di leggibilità. Se lo usi ovunque, il 20% del tuo codice sarà composto dalla parola “questo”!

In realtà

 baz = baz 

alzerà questo avvertimento

L’assegnazione alla variabile baz non ha alcun effetto

Quindi, quello che pensi sia sbagliato, l’ambito locale sovrascrive l’attributo di class, quindi DEVI usare esplicitamente this parola chiave per assegnare la variabile all’attributo di class.

Altrimenti la variabile contabilizzata nell’assegnazione è solo quella passata come parametro e quella di class è ignorata. Ecco perché this è utile, non è un fatto di leggibilità, è un fatto di decidere esplicitamente di quale baz stai parlando.

direi

usalo ovunque non lo utilizzi causerebbe ambiguità (o avvertimenti del compilatore, che sono più importanti), altrimenti lascia semplicemente. Dal momento che il suo scopo è esattamente quello di risolvere le ambiguità quando le assunzioni di default (prima controlla la gente del posto, quindi controlla gli attributi della class) non sono sufficienti.

this parola chiave si riferisce all’Oggetto di class su cui viene invocato un metodo.
Per esempio:

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

Qui in Abc() chiamiamo Xyz() che ha bisogno della class Object of Abc. Quindi possiamo passare this anziché il nuovo Abc() , perché se passiamo il nuovo Abc() qui chiamerà se stesso ancora e ancora.

Inoltre lo usiamo per differenziare le variabili di class e le variabili locali del metodo. per esempio

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

Qui this.a si riferisce alla variabile a della class Abc. Quindi avere lo stesso effetto di come usi il nuovo Abc().a; .

Quindi puoi dire che this riferisce all’object della class corrente.

È comune utilizzare questa parola chiave nel richiamo del costruttore esplicito . Puoi vedere un esempio dalla documentazione .

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

non è lo stesso di

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

Nel secondo caso la barra in ambito è il parametro, quindi lo si assegna a se stesso. this.bar rimane null .

È una preferenza personale: scegli uno stile e atteniscilo. Io personalmente uso this ma altri pensano che sia ridondante.

A seconda della convenzione, è ansible utilizzarlo per la leggibilità. Sottolinea il fatto che si tratta di una variabile object.

Mi piace anche avere argomenti setter con lo stesso nome della variabile (sembra migliore nella firma del metodo). Ne hai bisogno in questo caso.

Cerco sempre di usare this parola chiave su oggetti di class locali.

Lo uso per ricordarmi visivamente se un object è object statico o object di class.

Aiuta me e il compilatore a distinguere tra argomenti del metodo e oggetti di class locale.

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

Mi aiuta a ricordarmi visivamente se esiste un object locale in una class interna / nidificata / anonima per differenziarlo dagli oggetti di class che incapsulano. Perché se non c’è this prefisso, la mia convenzione mi ricorderà che è un object della class incapsulante

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

qui this è una parola chiave utilizzata quando c’è una variabile di istanza uguale alla variabile locale.
un altro uso di this è il sovraccarico del costruttore. può chiamare il costruttore in un costruttore sovraccarico.

Preferenza personale, ma la uso per risolvere solo le ambiguità e suppongo, nel caso molto raro, che sia ovvio che la variabile assegnata è un campo. Ci sono alcuni progetti in cui le persone usano “this.field” su ogni singolo riferimento di campo. Trovo questa pratica visivamente distraente al punto di essere odiosa, ma dovresti essere pronto a vedere un tale codice una volta ogni tanto.

Penso segretamente che c’è un posto speciale nell’inferno per le persone che scrivono 500 classi di linea che hanno in sé 275 parole chiave “queste”, ma questo stile si trova in alcuni progetti open source, quindi a ciascuno il suo credo.

Usalo per clonare oggetti (passando il riferimento di se stesso attraverso un costruttore di copie).

Utile per l’object che eredita 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. } }