Parola chiave this Java

In questo articolo, esploreremo il costruttore this in Java, come e dove utilizzarlo.

Costruttore this

Nel Java, il costruttore this viene utilizzato per riferirsi all'oggetto corrente all'interno di un metodo o costruttore. Ad esempio,

class Main {
　　　　int　instVar;
　　　　Main(int　instVar){
　　　　　　　　this.instVar　=　instVar;
　　　　　　　　System.out.println("Riferimento this=　"　+　this);
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　Main　obj　=　new　Main(8);
　　　　　　　　System.out.println("Riferimento oggetto=　"　+　obj);
　　　　}
}

Output：

Riferimento this=　com.ThisAndThat.MyClass@74a14482
Riferimento oggetto　=　com.ThisAndThat.MyClass@74a14482

Nel esempio sopra, abbiamo creato un oggetto chiamato obj della classe Main. Poi, abbiamo stampato il riferimento all'oggetto della classe obj e al costruttore this.

Qui, possiamo vedere che il riferimento obj e this sono gli stessi. Questo significa che questo è solo un riferimento all'oggetto corrente.

Utilizzare il costruttore this

In vari casi, si utilizza di solito il costruttore this.

Gestire la ambiguità dei nomi delle variabili utilizzando this

In Java, non è permesso dichiarare due o più variabili con lo stesso nome all'interno di un'area di validità (di classe o metodo). Tuttavia, le variabili di istanza e i parametri possono avere lo stesso nome. Ad esempio,

class　MyClass　{
　　　　//　variabile di istanza
　　　　int age;
　　　　//　parametro
　　　　MyClass(int　age){
　　　　　　　　age　=　age;
　　　　}
}

Nel programma sopra, le variabili di istanza e i parametri hanno lo stesso nome: age. Qui, a causa del nome non chiaro, il compilatore Java si confonde.

In questo caso, utilizziamo il costruttore this. Ad esempio,

Prima di tutto, diamo un'occhiata a un esempio che non utilizza il costruttore this:

class Main {
　　　　int age;
　　　　Main(int　age){
　　　　　　　　age　=　age;
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　Main　obj　=　new　Main(8);
　　　　　　　　System.out.println("obj.age = " + obj.age);
　　　　}
}

Output：

mc.age　=　0

Nel esempio sopra, abbiamo passato un valore 8 al costruttore. Tuttavia, l'output che otteniamo è 0. Questo è perché il compilatore Java si confonde a causa del nome non chiaro tra le variabili di istanza e i parametri.

Ora, permetteteci di riscrivere il codice sopra utilizzando il costruttore this.

class Main {
　　　　int age;
　　　　Main(int　age){
　　　　　　　　this.age　=　age;
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　Main　obj　=　new　Main(8);
　　　　　　　　System.out.println("obj.age = " + obj.age);
　　　　}
}

Output：

obj.age = 8

Ora, otteniamo l'output atteso. Questo perché quando viene chiamato il costruttore, il contenuto del costruttore viene sostituito dall'oggetto che chiama il costruttore. Pertanto, la variabile age viene assegnata con un valore di 8.

Inoltre, se il nome del parametro è diverso dal nome dell'istanza variabile, il compilatore aggiunge automaticamente la parola chiave this. Ad esempio il codice:

class Main {
　　　　int age;
　　　　Main(int i) {
　　　　　　　　age = i;
　　　　}
}

è equivalente a:

class Main {
　　　　int age;
　　　　Main(int i) {
　　　　　　　　this.age = i;
　　　　}
}

this e i getters e setters

Un'altra comune utilizzo della parola chiave this è nel corpo della classe.Metodi setter e getterAd esempio:

class Main {
　　　String name;
　　　// Metodo setter
　　　void setName(String name) {
　　　　　　　this.name = name;
　　　}
　　　// Metodo getter
　　　String getName() {
　　　　　　　return this.name;
　　　}
　　　public static void main(String[] args) {
　　　　　　　Main obj = new Main();
　　　　　　　// Chiamata ai metodi setter e getter
　　　　　　　obj.setName("Seagull");
　　　　　　　System.out.println("obj.name: " + obj.getName());
　　　}
}

Output：

obj.name: Seagull

In questo caso, abbiamo utilizzato la parola chiave this:

• Assegnare valori tramite i metodi setter

• Accedere ai valori tramite i metodi getter

L'uso di this nei costruttori sovraccaricati

Nel gestireQuando si sovraccarica il costruttorePotremmo dover chiamare un costruttore da un altro costruttore. In questo caso, non possiamo chiamare esplicitamente il costruttore. Invece, dobbiamo utilizzare la parola chiave this.

In questo contesto, utilizziamo un'altra forma della parola chiave this. Ossia this(). Facciamo un esempio

class Complex {
　　　　private int a, b;
　　　　// Costruttore con due parametri
　　　　private Complex(int i, int j) {
　　　　　　　　this.a = i;
　　　　　　　　this.b = j;
　　　　}
　　　　// Costruttore con un singolo parametro
　　　　private Complex(int i)
　　　　　　　　// Utilizza due parametri per chiamare il costruttore
　　　　　　　　this(i, i);　
　　　　}
　　　　// Costruttore senza parametri
　　　　private Complex()
　　　　　　　　// Utilizza un singolo parametro per chiamare il costruttore
　　　　　　　　this(0);
　　　　}
　　　　@Override
　　　　public String toString() {}}
　　　　　　　　return this.a + " + " + this.b + "i";
　　　　}
　　　　public static void main(String[] args) {
　　
　　　　　　　　　　　　　　　　//Creazione di un oggetto della classe Complex
　　　　　　　　　　　　　　　　//Chiamata al costruttore con due parametri　
　　　　　　　　Complex c1 = new Complex(2, 3);　
　　　　
　　　　　　　　//Chiamata al costruttore con un singolo parametro
　　　　　　　　Complex c2 = new Complex(3);
　　　　　　　　//Chiamata al costruttore senza parametri
　　　　　　　　Complex c3 = new Complex();
　　　　　　　　//Stampa l'oggetto
　　　　　　　　System.out.println(c1);
　　　　　　　　System.out.println(c2);
　　　　　　　　System.out.println(c3);
　　　　}
}

Output：

2 + 3i
3 + 3i
0 + 0i

Nell'esempio sopra, abbiamo utilizzato il chiave this,

• Chiamata al costruttore Complex(int i) dal costruttore Complex(int i, int j)

• Chiamata al costruttore Complex() dal costruttore Complex(int i)

Attenzione a questa riga,

System.out.println(c1);

In questo caso, quando stampiamo l'oggetto c1, l'oggetto viene convertito in una stringa. Durante questo processo, viene chiamato toString(). Poiché abbiamo sovrascritto il metodo toString() nella classe, otteniamo l'output da questo metodo.

　Uno dei principali vantaggi di this() è ridurre la quantità di codice ripetuto. Ma, quando si utilizza this(), dobbiamo essere particolarmente cauti.

　Questo perché chiamare un costruttore da un altro costruttore aggiunge un overhead e è un processo lento. Un altro grande vantaggio dell'uso di this() è ridurre la quantità di codice ripetuto.

Attenzione: Chiamare un costruttore da un altro costruttore si chiama chiamata costruttore esplicita.

this come parametro

Possiamo usare il chiave this per passare l'oggetto corrente come parametro a un metodo. Ad esempio,

class ThisExample {
　　　　//Declara le variabili
　　　　int x;
　　　　int y;
　　　　ThisExample(int x, int y) {
　　　　　　　　　　//Assegnazione delle variabili all'interno del costruttore
　　　　　　　　this.x = x;
　　　　　　　　this.y = y;
　　　　　　　　//Valori di x e y prima della chiamata all'metodo add()
　　　　　　　　System.out.println("Prima di passare this all'metodo addTwo():");
　　　　　　　　System.out.println("x = " + this.x + ", y = " + this.y);}}
　　　　　　　　//Chiamata all'metodo add(), passing this come parametro
　　　　　　　　add(this);
　　　　　　　　//Valori di x e y dopo la chiamata all'metodo add()
　　　　　　　　System.out.println("Dopo aver passato this all'metodo addTwo():");
　　　　　　　　System.out.println("x = " + this.x + ", y = " + this.y);}}
　　　　}
　　　　void add(ThisExample o){
　　　　　　　　o.x += 2;
　　　　　　　　o.y += 2;
　　　　}
}
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ThisExample obj = new ThisExample(1, -2);
　　　　}
}

Output：

Prima di passare this al metodo addTwo():
x = 1, y = -2
Dopo aver passato this al metodo addTwo():
x = 3, y = 0

Nell'esempio sopra, nel costruttore ThisExample(), presta attenzione alla seguente riga:

add(this);

In questo esempio, chiamiamo il metodo add() passando this come parametro. Poiché il simbolo this contiene un riferimento all'oggetto della classe obj, possiamo modificare i valori di x e y nel metodo add().