Parola chiave this {negli esempi}

A JavaRush, gli studenti vengono introdotti alla parola chiave letteralmente fin dalle prime lezioni 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 thisper 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, thisdovrebbe essere utilizzato in due casi:

1. Quando una variabile di istanza di classe e una variabile di metodo/costruttore hanno lo stesso nome;
2. 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.

Questo è tutto, non molto in realtà, solo due casi in cui viene utilizzata questa temuta parola chiave. Ora diamo un'occhiata a queste due situazioni con esempi.

Esempio uno: la variabile di istanza e la variabile di metodo hanno lo stesso nome

Diciamo di avere una classe Humanper la quale è definito il campo "nome": Creiamo nameun 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: setNameString newNamesetName

name = newName;

Cioè, infatti, abbiamo introdotto una nuova variabile newNamee 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 nameappartiene alla classe Humane l'altro String nameal 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 - namedal metodo setName: e si scopre che assegni semplicemente un valore a una variabile nameda questo metodo. Il che ovviamente non ha alcun senso. Occorreva quindi in qualche modo distinguere una variabile nameda una classe Humanda una variabile nameda un metodo setNamee 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: Si riferirà cioè thisall'oggetto chiamante, come detto all'inizio dell'articolo. Di conseguenza, il nome della persona setNameverrà 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 Humane gli dà un nome: E di seguito è riportato il codice del programma con la parola chiave 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 thisevita 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 classi Human:

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 agee 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 thischiamare 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.

Questo è tutto =). Notiamo infine che la parola chiave this in Java viene utilizzata solo come parte di metodi o costruttori di un'istanza di classe. Ma implicitamente, la parola chiave thisviene passata a tutti i metodi tranne quelli statici (per questo motivo viene thisspesso 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é Thisnon fa paura.