Java questa parola chiave

Su CodeGym, gli studenti vengono introdotti a Java questa parola chiave letteralmente dalle prime lezioni. Nel tempo, il suo significato diventa chiaro. Ma guardando indietro, molte persone probabilmente ammettono a se stesse che per molto tempo non sono riuscite a capire lo Zen di questa parola chiave. Questo articolo tirerà indietro il sipario sui segreti della parola chiave this per chiunque non sia ancora stato in grado di farlo ... Ho il riferimento Java di Schildt , quindi a pagina 171 puoi vedere che la parola chiave this è necessario affinché un metodo faccia riferimento all'oggetto che lo ha chiamato. Potremmo concludere la lezione con questo. Ma abbiamo bisogno di specifiche. Di norma, è necessario utilizzarlo in due casi:

1. Quando una variabile di istanza e una variabile metodo/costruttore hanno lo stesso nome;
2. Quando è necessario chiamare un tipo specifico di costruttore (ad esempio, un costruttore predefinito o un costruttore parametrizzato) da un altro tipo di costruttore. Questo è anche chiamato una chiamata esplicita del costruttore.

E questo è tutto: ci sono solo due casi in cui viene utilizzata questa spaventosa parola chiave. Ora diamo un'occhiata a questi due casi negli esempi.

Esempio 1: una variabile di istanza e una variabile di metodo hanno lo stesso nome.

Supponiamo di avere una classe Human che definisce un campo name: creiamo un setter per la variabile name (il setter è perfettamente funzionante — qui non c'è problema):

class Human {
    String name;


    public void setName(String newName) {
        name = newName;
    }
}

Nota che passiamo String newName al metodo setter setName Abbiamo dichiarato una nuova variabile e avremmo potuto chiamarla come volevamo perché sarà visibile solo all'interno delle parentesi graffe ({}) che racchiudono il metodo setName . Si noti che il setter ha una sola riga:

name = newName;

Qui abbiamo introdotto una nuova variabile chiamata newName e l'abbiamo assegnata alla variabile nome esistente dell'oggetto . Molti programmatori potrebbero trovare strano introdurre una variabile con un nuovo nome quando alla fine stiamo parlando della stessa cosa. Cioè, stiamo parlando del campo del nome nella classe Umano . Ecco perché i creatori di Java hanno escogitato un modo per utilizzare convenientemente lo stesso nome di variabile. In altre parole, perché avere due nomi per una variabile che denota la stessa cosa. In altre parole, vogliamo fare qualcosa del genere:

class Human {
    String name;


    public void setName(String name) {
        name = name;
    }
}

Ma qui incontriamo un problema . Ora abbiamo due variabili con lo stesso nome. Un nome String appartiene alla classe Human , mentre l'altro nome String appartiene al relativo metodo setName . Di conseguenza, la JVM non saprebbe a quale variabile ti riferisci quando scrivi la seguente riga nel setter:

name = name;

Java presuppone che tu intenda la variabile nome più vicina , cioè quella dal metodo setName : Quindi si scopre che stai semplicemente assegnando la variabile nome del metodo a se stessa. Il che ovviamente non ha alcun senso. Pertanto, il linguaggio aveva bisogno di un modo per distinguere la variabile name della classe Human dalla variabile name nel metodo setName . Questo problema è stato risolto introducendo la parola chiave this , che in questo caso indica che si intende referenziare la variabile associata ad un'istanza della classe Human , non la variabile nel metodo: In altre parole, thissi riferisce all'oggetto chiamante, come accennato all'inizio dell'articolo. Di conseguenza, il metodo setName imposta il nome della persona sull'oggetto creato. Di seguito è riportato il codice del programma senza utilizzare la parola chiave this . Il codice crea un oggetto Human e gli assegna un nome: Ed ecco il codice con questa parola chiave:

public class Solution {
    public static void main(String[] args) {
        Human human1 = new Human();
        human1.setName("Vinny");
        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, questo ci consente di evitare di introdurre nuove variabili per denotare la stessa cosa, rendendo il codice più pulito e meno ingombro di variabili extra.

Esempio 2: utilizzo di this per una chiamata esplicita al costruttore

Chiamare un costruttore da un altro può essere utile quando si hanno (stranamente) più costruttori e non si desidera che il nuovo costruttore duplichi il codice di inizializzazione precedentemente scritto in un altro costruttore. Confuso? Non è così spaventoso come sembra. Guarda il codice qui sotto. Ha due costruttori per la classe 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) {
        // Call the constructor with two parameters
        this(age, weight);
        // and then initialize the missing variable
        this.height = height;
    }
}

Qui abbiamo prima fornito un costruttore con due parametri: int age e int weight . Supponiamo che abbia due righe di codice:

this.age = age;
this.weight = weight;

Successivamente decidiamo di aggiungere un altro costruttore con tre parametri, aggiungendo l'altezza ai parametri esistenti di età e peso. Potresti scrivere il nuovo costruttore in questo modo:

this.age = age;
this.weight = weight;
this.height = height;

Ma invece di ripetere il codice esistente in questo costruttore, puoi utilizzare la parola chiave this per chiamare esplicitamente il costruttore con due parametri:

this(age, weight);
// and then initialize the missing variable:
this.height = height;

È come se stessimo dicendo al costruttore a tre parametri:

• chiama questo altro costruttore che ha due parametri
• e quindi aggiungere un'altra variabile.

Questo è tutto =). Infine, notiamo che in Java la parola chiave this viene utilizzata solo nei metodi e nei costruttori. Ma questo viene passato implicitamente a tutti i metodi non statici (ecco perché questo è spesso chiamato parametro implicito) e può essere usato per fare riferimento all'oggetto che ha chiamato il metodo. Non aver paura di questa parola chiave, perché non fa paura.