Šiame straipsnyje su pavyzdžių pagalba sužinosime apie šį „Java“ raktinį žodį, kaip ir kur juos naudoti.
šis raktinis žodis
„Java“ sistemoje šis raktinis žodis naudojamas norint nurodyti esamą metodo ar konstruktoriaus objektą. Pavyzdžiui,
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); ) )
Išvestis :
ši nuoroda = Main @ 23fc625e objekto nuoroda = Main @ 23fc625e
Ankstesniame pavyzdyje mes sukūrėme objektą, pavadintą obj klasės „Main“. Tada atspausdiname nuorodą į objekto objektą ir thisklasės raktinį žodį.
Čia galime pamatyti, kad abiejų objektų ir nuorodų nuoroda thisyra ta pati. Tai reiškia, kad tai ne kas kita, o nuoroda į esamą objektą.
Šio raktinio žodžio naudojimas
Yra įvairių situacijų, kai thisdažniausiai naudojamas raktinis žodis.
Tai naudojant dviprasmybės kintamųjų pavadinimams
„Java“ sistemoje negalima deklaruoti dviejų ar daugiau kintamųjų, turinčių tą patį pavadinimą (srities ar metodo sritis). Tačiau egzempliorių kintamieji ir parametrai gali turėti tą patį pavadinimą. Pavyzdžiui,
class MyClass ( // instance variable int age; // parameter MyClass(int age)( age = age; ) )
Pirmiau pateiktoje programoje egzemplioriaus kintamasis ir parametras turi tą patį pavadinimą: amžius. Čia „Java“ kompiliatorius yra painiojamas dėl pavadinimo neaiškumų.
Esant tokiai situacijai, mes naudojame šį raktinį žodį. Pavyzdžiui,
Pirmiausia pažiūrėkime pavyzdį nenaudodami thisraktinio žodžio:
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); ) )
Išvestis :
mcage = 0
Ankstesniame pavyzdyje mes perdavėme 8kaip vertę konstruktoriui. Tačiau mes gauname 0kaip rezultatą. Taip yra todėl, kad „Java“ kompiliatorius painiojasi dėl pavadinimų dviprasmybės tarp egzemplioriaus kintamojo ir parametro.
Dabar perrašykime aukščiau nurodytą kodą naudodami thisraktinį žodį.
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); ) )
Išvestis :
obj.age = 8
Dabar mes gauname laukiamą rezultatą. Taip yra todėl, kad kai iškviečiamas konstruktorius, thisviduje konstruktorius pakeičiamas objektu obj, kuris iškvietė konstruktorių. Taigi amžiaus kintamajam priskiriama 8 reikšmė.
Be to, jei parametro ir egzemplioriaus kintamojo pavadinimas skiriasi, kompiliatorius automatiškai prideda šį raktinį žodį. Pavyzdžiui, kodas:
class Main ( int age; Main(int i) ( age = i; ) )
yra lygiavertis:
class Main ( int age; Main(int i) ( this.age = i; ) )
tai su „Getters and Setters“
Kitas įprastas thisraktinių žodžių naudojimas yra klasių nustatytojų ir matuoklių metodai. Pavyzdžiui:
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()); ) )
Išvestis :
obj.name: Toshiba
Čia mes naudojome thisraktinį žodį:
- priskirti vertę seterio metodo viduje
- pasiekti vertę „getter“ metodo viduje
Tai naudojant konstruktoriaus perkrovoje
Dirbdami su konstruktoriaus perkrova, gali tekti pasikviesti vieną konstruktorių iš kito konstruktoriaus. Tokiu atveju negalime tiesiogiai paskambinti konstruktoriui. Vietoj to turime naudoti thisraktinį žodį.
Čia mes naudojame kitą šio raktinio žodžio formą. Tai yra this(),. Paimkime pavyzdį,
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); ) )
Išvestis :
2 + 3i 3 + 3i 0 + 0i
Ankstesniame pavyzdyje mes naudojome thisraktinį žodį,
- paskambinti konstruktoriui
Complex(int i, int j)iš konstruktoriausComplex(int i) - paskambinti konstruktoriui
Complex(int i)iš konstruktoriausComplex()
Atkreipkite dėmesį į eilutę,
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); ) )
Išvestis :
Prieš perduodant tai metodui „addTwo ()“: x = 1, y = -2 Perkėlus tai į metodą „addTwo ()“: x = 3, y = 0
Ankstesniame pavyzdyje konstruktoriaus viduje ThisExample()atkreipkite dėmesį į liniją,
add(this);
Čia mes vadiname add()metodą, pateikdami tai kaip argumentą. Kadangi šiame raktažodyje yra nuoroda į klasės obj objektą, add()metodo viduje galime pakeisti x ir y reikšmę .
