Šajā rakstā mēs uzzināsim par šo atslēgvārdu Java, kā un kur tos izmantot, izmantojot piemērus.
šo atslēgvārdu
Java valodā šis atslēgvārds tiek izmantots, lai atsauktos uz pašreizējo objekta metodi vai konstruktoru. Piemēram,
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); ) )
Izeja :
šī atsauce = Main @ 23fc625e objekta atsauce = Main @ 23fc625e
Iepriekš minētajā piemērā mēs izveidojām objektu ar nosaukumu obj klases klases Main. Pēc tam mēs izdrukājam atsauci uz thisklases objektu obj un atslēgvārdu.
Šeit mēs varam redzēt, ka gan obj, gan atsauce thisir vienāda. Tas nozīmē, ka tas nav nekas cits kā atsauce uz pašreizējo objektu.
Šī atslēgvārda izmantošana
Ir dažādas situācijas, kad thisparasti tiek izmantots atslēgvārds.
Izmantojot to neskaidrību mainīgo nosaukumos
Java valodā nav atļauts deklarēt divus vai vairākus mainīgos ar tādu pašu nosaukumu darbības jomā (klases darbības joma vai metodes darbības joma). Tomēr eksemplāru mainīgajiem un parametriem var būt tāds pats nosaukums. Piemēram,
class MyClass ( // instance variable int age; // parameter MyClass(int age)( age = age; ) )
Iepriekš minētajā programmā instances mainīgajam un parametram ir tāds pats nosaukums: vecums. Šeit Java sastādītājs ir sajaukts nosaukuma neskaidrības dēļ.
Šādā situācijā mēs izmantojam šo atslēgvārdu. Piemēram,
Vispirms apskatīsim piemēru, neizmantojot thisatslēgvārdu:
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); ) )
Izeja :
mcage = 0
Iepriekš minētajā piemērā mēs 8kā vērtību nodevām konstruktoram. Tomēr mēs iegūstam 0kā rezultātu. Tas notiek tāpēc, ka Java kompilators sajaucas, jo nosaukumos ir neskaidrības starp mainīgo un parametru.
Tagad pārrakstīsim iepriekš minēto kodu, izmantojot thisatslēgvārdu.
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); ) )
Izeja :
obj.age = 8
Tagad mēs iegūstam gaidīto produkciju. Tas ir tāpēc, ka, thisizsaucot konstruktoru , iekšpusē konstruktoru aizstāj objekta obj, kas izsaucis konstruktoru. Tādējādi vecuma mainīgajam tiek piešķirta 8. vērtība.
Turklāt, ja parametra un instances mainīgā nosaukums atšķiras, kompilators automātiski pievieno šo atslēgvārdu. Piemēram, kods:
class Main ( int age; Main(int i) ( age = i; ) )
ir ekvivalents:
class Main ( int age; Main(int i) ( this.age = i; ) )
tas ar Getters un Setters
Vēl viens thisatslēgvārda kopīgs lietojums ir klases iestatītāju un getteru metodes. Piemēram:
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()); ) )
Izeja :
obj.nosaukums: Toshiba
Šeit mēs izmantojām thisatslēgvārdu:
- piešķirt vērtību setera metodes iekšienē
- lai piekļūtu vērtībai getter metodes iekšienē
Izmantojot to konstruktora pārslodzē
Strādājot ar konstruktora pārslodzi, mums var nākties izsaukt vienu konstruktoru no cita konstruktora. Šādā gadījumā mēs nevaram tieši piezvanīt konstruktoram. Tā vietā mums ir jāizmanto thisatslēgvārds.
Šeit mēs izmantojam citu šī atslēgvārda formu. Tas ir this(),. Ņemsim piemēru,
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); ) )
Izeja :
2 + 3i 3 + 3i 0 + 0i
Iepriekš minētajā piemērā mēs izmantojām thisatslēgvārdu,
- izsaukt konstruktoru
Complex(int i, int j)no konstruktoraComplex(int i) - izsaukt konstruktoru
Complex(int i)no konstruktoraComplex()
Ievērojiet līniju,
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); ) )
Izeja :
Pirms nododat to metodei addTwo (): x = 1, y = -2 Pēc tam, kad esat to nodevis metodei addTwo (): x = 3, y = 0
Iepriekš minētajā piemērā konstruktora iekšpusē ThisExample()pamaniet līniju,
add(this);
Šeit mēs saucam add()metodi, nododot to kā argumentu. Tā kā šajā atslēgvārdā ir atsauce uz klases objekta obj, mēs varam mainīt x un y vērtību add()metodes iekšienē .
