Dovrei usare la parola chiave “this” quando voglio fare riferimento alle variabili di istanza all’interno di un metodo?

Il mio insegnante dice che quando cerco di accedere a una variabile di istanza all’interno di un metodo, dovrei sempre usare la parola chiave, altrimenti eseguirò una doppia ricerca. Una ricerca dell’ambito locale e quindi una ricerca dell’ambito dell’istanza.

Esempio:

 public class Test(){ int cont=0; public void Method(){ System.out.println(cont);//Should I use This.cont instead? } } 

Spero che abbia torto, ma non riesco a trovare alcun argomento.

No, usalo solo quando hai un conflitto di nomi come quando un parametro metodo ha lo stesso nome di un campo istanza che sta impostando.

Può essere usato in altri momentjs, ma molti di noi sentono che aggiunge semplicemente verbosità inutili al codice.

È necessario utilizzarlo, se necessario, a causa di un conflitto di nomi, sebbene sia meglio evitarlo completamente.

Puoi usare this se lo desideri. È puramente una questione di gusti.

Dovresti usare this nei tuoi compiti scolastici se il tuo insegnante lo richiede.

this è un alias o un nome per l’istanza corrente all’interno dell’istanza. È utile per disambiguare le variabili di istanza dai locals (inclusi i parametri), ma può essere usato da solo per riferirsi semplicemente a variabili e metodi membri, richiamare altri sovraccarichi del costruttore o semplicemente per fare riferimento all’istanza.
Vedi Java: quando utilizzare la parola chiave “this”
Anche questo si riferisce all’attuale object. Se hai una class con le variabili int A e un metodo xyz parte della class ha int A, giusto per differenziare quale ‘A’ ti riferisci, userai questo.A. Questo è solo un esempio.

 public class Test { int a; public void testMethod(int a) { this.a = a; //Here this.a is variable 'a' of this instance. parameter 'a' is parameter. } } 

Quindi puoi dirlo
questa parola chiave può essere utilizzata per (non può essere utilizzata con metodi statici):

  1)To get reference of an object through which that method is called within it(instance method). 2)To avoid field shadowed by a method or constructor parameter. 3)To invoke constructor of same class. 4)In case of method overridden, this is used to invoke method of current class. 5)To make reference to an inner class. eg ClassName.this 

Il tuo insegnante è corretto che comporterà una doppia ricerca per il compilatore se non si utilizza this parola chiave. Prima il compilatore cercherà l’ambito locale e quindi l’ambito dell’istanza se il compilatore non è in grado di trovare la variabile nell’ambito locale.

Inoltre, mentre il compilatore sta convertendo il codice in bytecode, il compilatore farà precedere tutte le variabili di istanza con this parola chiave. Quindi, se tu fai uso di this parola chiave, in realtà stai riducendo l’onere per il compilatore e il codice verrà compilato più velocemente.

Dato che tutti hanno fornito esempi di nomi disambiguanti, darò un esempio quando uso this aiuto:

 public class Person { private final firstName; private final lastName; private final Date birthdate; private final Address address; @Override public boolean equals(Object otherObject) { if (!(otherObject instanceof Person) { return false; } Person otherPerson = (Person) otherObject; // Using this here help distinguishing the current instance and the other. return this.firstName.equals(otherPerson.firstName) && this.lastName.equals(otherPerson.lastName) && this.birthdate.equals(otherPerson.birthDate) && this.address.equals(otherPerson.address); } } 

this si applica solo al caso in cui un parametro ha lo stesso nome di una proprietà di class.

 public class Dog { String name; public Dog(String name) { name = name; //but which name? Are we just assigning a variable to itself? // here you could say this.name = name. Or you could rename one of the variables to resolve ambiguity } } 

Occasionalmente uso this causa del completamento automatico (semplifica la vita), ma li pulisco in seguito.

Ricorda, la chiarezza è la chiave. In questo caso, è ovvio che cont è una variabile di class, ma se si stesse scrivendo un’enorme class con pile di variabili d’istanza, si potrebbe considerare l’uso di this per chiarezza.

Devi anche solo usarlo quando c’è una collisione di nomi, ad es

 public class Ex { int num; public Ex(int num) { this.num = num; } } 

In questo esempio, mentre num = num causerebbe una collisione, “questo” lo evita. Questa è l’unica volta in cui è assolutamente necessario, ma, di nuovo, spesso la chiarezza è una priorità più alta.

Un altro posto che viene spesso usato per la leggibilità è quando un object di class interna si riferisce a un campo del suo object contenitore.

 public class Foo { String foostring; /* snip lots of code */ private class Foohelper { void helperMethod(String bazstring) { Foo.this.foostring = bazstring; // etc. } } } 

Il compilatore non ha bisogno di questo, ma rende più chiara la situazione in cui cercare le foostring . Oltre a questo (!), Ho completamente qualificato i nomi dei campi nel costruttore in cui potrebbero essere nascosti dai nomi dei parametri, come molti altri poster hanno illustrato qui.

[Modifica: Ora che ci penso, ci sono dei posti in cui il compilatore ha bisogno di questo, per esempio, se Foohelper.toString() vuole chiamare Foo.toString() .]