A JavaRush, gli studenti vengono introdotti alla parola chiave letteralmente fin dalle prime lezioni
e si scopre che assegni semplicemente un valore a una variabile
Si riferirà cioè
E di seguito è riportato il codice del programma con la parola chiave
this
. E col tempo diventa chiaro cosa significa. Ma molti, guardando indietro, probabilmente diranno onestamente a se stessi che per molto tempo non sono riusciti a realizzare lo zen di questa parola chiave. In questo articolo solleviamo il velo dei segreti sull'uso delle parole chiave this
per coloro che ancora non riescono a capirlo... Benvenuto! Se prendi il libro di riferimento Java di Schildt , a pagina 171 leggerai che this
è necessaria una parola chiave affinché un metodo possa fare riferimento all'oggetto che lo ha chiamato. Questa potrebbe davvero essere la fine. Ma abbiamo bisogno di dettagli. Di norma, this
dovrebbe essere utilizzato in due casi:
- Quando una variabile di istanza di classe e una variabile di metodo/costruttore hanno lo stesso nome;
- Quando è necessario chiamare un costruttore di un tipo (ad esempio, un costruttore predefinito o con parametri) da un altro. Questa è anche chiamata chiamata esplicita del costruttore.
Esempio uno: la variabile di istanza e la variabile di metodo hanno lo stesso nome
Diciamo di avere una classeHuman
per la quale è definito il campo "nome": Creiamo name
un setter per la variabile (il setter funziona abbastanza e non ci sono trucchi qui): Nota che stiamo passando la variabile al metodo (setter ) . Abbiamo introdotto una nuova variabile e (in generale) potremmo chiamarla come vogliamo perché sarebbe visibile solo all'interno delle {parentesi graffe} del metodo . Notare che c'è una riga nel setter: setName
String newName
setName
name = newName;
Cioè, infatti, abbiamo introdotto una nuova variabile newName
e l'abbiamo assegnata ad una variabile già esistente nella classe name
. Molti programmatori hanno pensato che fosse strano introdurre una variabile con un nuovo nome se alla fine si tratta della stessa cosa. Informazioni sul nome nella classe Human
. Pertanto, gli sviluppatori del linguaggio hanno pensato di rendere conveniente l'utilizzo di un nome di variabile. In altre parole, perché avere due nomi per una variabile che significa la stessa cosa? Cioè vorrei fare una cosa del genere: Ma in questo caso sorge un problema . Ora abbiamo due variabili che hanno lo stesso nome. Uno String name
appartiene alla classe Human
e l'altro String name
al suo metodo setName
. Pertanto, la macchina Java non sa quale variabile intendi quando scrivi una stringa in un setter:
name = name;
Java prende quello più vicino - name
dal metodo setName
:
name
da questo metodo. Il che ovviamente non ha alcun senso. Occorreva quindi in qualche modo distinguere una variabile name
da una classe Human
da una variabile name
da un metodo setName
e per risolvere questo problema è stata introdotta la parola chiave this
, che in questo caso indicherà che è necessario chiamare una variabile non di un metodo, ma di una classe Human
:
this
all'oggetto chiamante, come detto all'inizio dell'articolo. Di conseguenza, il nome della persona setName
verrà impostato tramite il setter sull'oggetto creato. Di seguito è riportato il codice senza utilizzare la parola chiave this
. Il codice crea un oggetto di classe Human
e gli dà un nome:
this
:
public class Solution{
public static void main(String[] args) {
Human human1 = new Human();
human1.setName("Volodya");
human1.print();
}
}
class Human{
String name;
public String getName() {
return name;
}
public void setName(String name){
this.name = name;
}
void print(){
System.out.println(name);
}
}
Pertanto, si this
evita di introdurre nuove variabili per denotare la stessa cosa, il che rende il codice meno “sovraccarico” di variabili aggiuntive.
Esempio due: utilizzo di this per chiamare esplicitamente un costruttore
Chiamare un costruttore da un altro può essere utile quando (stranamente) hai diversi costruttori e non vuoi riscrivere il codice di inizializzazione fornito nel costruttore in precedenza in un nuovo costruttore. Confuso? Non tutto è così spaventoso come sembra. Guarda il codice qui sotto, ha due costruttori di classiHuman
:
class Human{
int age;
int weight;
int height;
Human(int age, int weight){
this.age = age;
this.weight = weight;
}
Human(int age, int weight, int height){
//you call the constructor with two parameters
this(age, weight);
//and add the missing variable
this.height = height;
}
}
Qui abbiamo prima un costruttore a due parametri che accetta int age
e int weight
. Diciamo che abbiamo scritto due righe di codice:
this.age = age;
this.weight = weight;
e poi hanno deciso di aggiungere un altro costruttore, con tre parametri, che, oltre all'età e al peso, prende anche l'altezza. Nel nuovo costruttore potresti scrivere questo:
this.age = age;
this.weight = weight;
this.height = height;
Ma invece di ripetere il codice che hai già scritto in questo costruttore, puoi utilizzare una parola chiave per this
chiamare esplicitamente il costruttore con due parametri:
this(age, weight);
// and add the missing variable:
this.height = height;
Quindi stai dicendo al costruttore con tre parametri:
- chiamare questo costruttore, che ha due parametri.
- e aggiungi la variabile mancante.
this
viene passata a tutti i metodi tranne quelli statici (per questo motivo viene this
spesso chiamata parametro implicito) e può essere utilizzata per fare riferimento all'oggetto che ha chiamato il metodo. Non c'è bisogno di aver paura di questa parola chiave, perché This
non fa paura.
GO TO FULL VERSION