V tomto článku sa dozvieme o tomto kľúčovom slove v Jave, ako a kde ich použiť pomocou príkladov.
toto kľúčové slovo
V Jave sa toto kľúčové slovo používa na označenie aktuálneho objektu vo vnútri metódy alebo konštruktora. Napríklad,
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); ) )
Výstup :
this reference = Main @ 23fc625e reference objektu = Main @ 23fc625e
Vo vyššie uvedenom príklade sme vytvorili objekt s názvom obj triedy Main. Potom vytlačíme odkaz na objekt obj a thiskľúčové slovo triedy.
Tu vidíme, že odkaz na oba obj a thisje rovnaký. Znamená to, že to nie je nič iné ako odkaz na aktuálny objekt.
Použitie tohto kľúčového slova
Existujú rôzne situácie, keď sa thiskľúčové slovo bežne používa.
Toto sa používa pre názvy premenných nejednoznačnosti
V prostredí Java nie je povolené deklarovať dve alebo viac premenných s rovnakým názvom v rámci rozsahu (rozsah triedy alebo rozsah metódy). Premenné a parametre inštancie však môžu mať rovnaký názov. Napríklad,
class MyClass ( // instance variable int age; // parameter MyClass(int age)( age = age; ) )
Vo vyššie uvedenom programe majú premenná inštancie a parameter rovnaký názov: age. Tu je kompilátor Java zmätený kvôli nejednoznačnosti názvu.
V takejto situácii používame toto kľúčové slovo. Napríklad,
Najprv si ukážeme príklad bez použitia thiskľúčového slova:
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); ) )
Výstup :
mc.age = 0
V uvedenom príklade sme prešli 8ako hodnota do konštruktora. Dostávame sa však 0ako výstup. Je to preto, že kompilátor Java je zmätený z dôvodu nejednoznačnosti mien medzi inštanciou premenná a parameter.
Teraz prepíšeme vyššie uvedený kód pomocou thiskľúčového slova.
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); ) )
Výstup :
obj.age = 8
Teraz dostávame očakávaný výstup. Je to preto, že keď sa volá konštruktor, thisvo vnútri konštruktora sa nahradí objekt obj, ktorý zavolal konštruktor. Preto je vekovej premennej priradená hodnota 8.
Ak je názov parametra a premennej inštancie odlišný, prekladač automaticky pripojí toto kľúčové slovo. Napríklad kód:
class Main ( int age; Main(int i) ( age = i; ) )
je ekvivalentné s:
class Main ( int age; Main(int i) ( this.age = i; ) )
toto s Gettermi a Settermi
Ďalším bežným používaním thiskľúčového slova je metóda setterov a geterov v triede. Napríklad:
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()); ) )
Výstup :
obj.name: Toshiba
Tu sme použili thiskľúčové slovo:
- priradiť hodnotu vnútri metódy setter
- na prístup k hodnote vo vnútri metódy getra
Pomocou tohto v preťažení konštruktora
Pri práci s preťažením konštruktora možno budeme musieť vyvolať jeden konštruktor z iného konštruktora. V takom prípade nemôžeme explicitne zavolať konštruktor. Namiesto toho musíme použiť thiskľúčové slovo.
Tu používame inú formu tohto kľúčového slova. To znamená, že this(). Zoberme si príklad,
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); ) )
Výstup :
2 + 3i 3 + 3i 0 + 0i
Vo vyššie uvedenom príklade sme použili thiskľúčové slovo,
- zavolať konštruktora
Complex(int i, int j)z konštruktoraComplex(int i) - zavolať konštruktora
Complex(int i)z konštruktoraComplex()
Všimnite si riadok,
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); ) )
Výstup :
Pred odovzdaním do metódy addTwo (): x = 1, y = -2 Po odovzdaní do metódy addTwo (): x = 3, y = 0
Vo vyššie uvedenom príklade si vo vnútri konštruktora ThisExample()všimnite riadok,
add(this);
Tu voláme add()metódu odovzdaním ako argumentu. Pretože toto kľúčové slovo obsahuje odkaz na objekt obj triedy, môžeme vo vnútri add()metódy zmeniť hodnotu xay .
