În acest articol, vom afla despre acest cuvânt cheie în Java, cum și unde să le folosim cu ajutorul exemplelor.
acest cuvânt cheie
În Java, acest cuvânt cheie este utilizat pentru a se referi la obiectul curent din interiorul unei metode sau a unui constructor. De exemplu,
class Main ( int instVar; Main(int instVar)( this.instVar = instVar; System.out.println("this reference = " + this); ) public static void main(String() args) ( Main obj = new Main(8); System.out.println("object reference = " + obj); ) )
Ieșire :
această referință = Main @ 23fc625e referință obiect = Main @ 23fc625e
În exemplul de mai sus, am creat un obiect numit obj din clasa Main. Apoi imprimăm referința la obiectul obiect și la thiscuvântul cheie al clasei.
Aici, putem vedea că referința ambelor obi și thiseste aceeași. Înseamnă că aceasta nu este altceva decât referința la obiectul curent.
Utilizarea acestui cuvânt cheie
Există diverse situații în care thiscuvântul cheie este utilizat în mod obișnuit.
Folosind aceasta pentru nume de variabile de ambiguitate
În Java, nu este permisă declararea a două sau mai multe variabile care au același nume în interiorul unui domeniu (domeniul clasei sau domeniul metodei). Cu toate acestea, variabilele și parametrii de instanță pot avea același nume. De exemplu,
class MyClass ( // instance variable int age; // parameter MyClass(int age)( age = age; ) )
În programul de mai sus, variabila de instanță și parametrul au același nume: vârstă. Aici, compilatorul Java este confuz din cauza ambiguității numelui.
Într-o astfel de situație, folosim acest cuvânt cheie. De exemplu,
Mai întâi, să vedem un exemplu fără a utiliza thiscuvânt cheie:
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); ) )
Ieșire :
mc.age = 0
În exemplul de mai sus, am trecut 8ca valoare constructorului. Cu toate acestea, obținem 0ca rezultat. Acest lucru se datorează faptului că compilatorul Java devine confuz din cauza ambiguității în nume între instanță variabilă și parametru.
Acum, să rescriem codul de mai sus folosind thiscuvânt cheie.
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); ) )
Ieșire :
obj.age = 8
Acum, obținem rezultatul scontat. Acest lucru se datorează faptului că atunci când este chemat constructorul, thisîn interiorul constructorului este înlocuit cu obiectul obiect care a numit constructorul. Prin urmare, variabilei de vârstă i se atribuie valoarea 8.
De asemenea, dacă numele parametrului și variabilei de instanță este diferit, compilatorul adaugă automat acest cuvânt cheie. De exemplu, codul:
class Main ( int age; Main(int i) ( age = i; ) )
este echivalent cu:
class Main ( int age; Main(int i) ( this.age = i; ) )
asta cu Getters and Setters
O altă utilizare obișnuită a thiscuvintelor cheie este în metodele de setare și obținere a unei clase. De exemplu:
class Main ( String name; // setter method void setName( String name ) ( this.name = name; ) // getter method String getName()( return this.name; ) public static void main( String() args ) ( Main obj = new Main(); // calling the setter and the getter method obj.setName("Toshiba"); System.out.println("obj.name: "+obj.getName()); ) )
Ieșire :
obiect.nume: Toshiba
Aici am folosit thiscuvinte cheie:
- pentru a atribui valoare în interiorul metodei setter
- pentru a accesa valoarea din interiorul metodei getter
Folosind aceasta în supraîncărcarea constructorului
În timp ce lucrăm cu supraîncărcarea constructorului, ar putea fi necesar să invocăm un constructor dintr-un alt constructor. Într-un astfel de caz, nu putem apela constructorul în mod explicit. În schimb, trebuie să folosim thiscuvinte cheie.
Aici, folosim o formă diferită a acestui cuvânt cheie. Adică this(). Să luăm un exemplu,
class Complex ( private int a, b; // constructor with 2 parameters private Complex( int i, int j )( this.a = i; this.b = j; ) // constructor with single parameter private Complex(int i)( // invokes the constructor with 2 parameters this(i, i); ) // constructor with no parameter private Complex()( // invokes the constructor with single parameter this(0); ) @Override public String toString()( return this.a + " + " + this.b + "i"; ) public static void main( String() args ) ( // creating object of Complex class // calls the constructor with 2 parameters Complex c1 = new Complex(2, 3); // calls the constructor with a single parameter Complex c2 = new Complex(3); // calls the constructor with no parameters Complex c3 = new Complex(); // print objects System.out.println(c1); System.out.println(c2); System.out.println(c3); ) )
Ieșire :
2 + 3i 3 + 3i 0 + 0i
În exemplul de mai sus, am folosit thiscuvinte cheie,
- a apela constructorul
Complex(int i, int j)din constructorComplex(int i) - a apela constructorul
Complex(int i)din constructorComplex()
Observați linia,
System.out.println(c1);
Here, when we print the object c1, the object is converted into a string. In this process, the toString() is called. Since we override the toString() method inside our class, we get the output according to that method.
One of the huge advantages of this() is to reduce the amount of duplicate code. However, we should be always careful while using this().
This is because calling constructor from another constructor adds overhead and it is a slow process. Another huge advantage of using this() is to reduce the amount of duplicate code.
Note: Invoking one constructor from another constructor is called explicit constructor invocation.
Passing this as an Argument
We can use this keyword to pass the current object as an argument to a method. For example,
class ThisExample ( // declare variables int x; int y; ThisExample(int x, int y) ( // assign values of variables inside constructor this.x = x; this.y = y; // value of x and y before calling add() System.out.println("Before passing this to addTwo() method:"); System.out.println("x = " + this.x + ", y = " + this.y); // call the add() method passing this as argument add(this); // value of x and y after calling add() System.out.println("After passing this to addTwo() method:"); 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); ) )
Ieșire :
Înainte de a trece acest lucru la addTwo () metoda: x = 1, y = -2 După ce a trecut acest lucru la addTwo () metoda: x = 3, y = 0
În exemplul de mai sus, în interiorul constructorului ThisExample(), observați linia,
add(this);
Aici, apelăm add()metoda trecând aceasta ca argument. Deoarece acest cuvânt cheie conține referința la obiectul obiect al clasei, putem modifica valoarea lui x și y în interiorul add()metodei.
